{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "e38c27d7-ebfe-406f-aa9f-07f9d6662d52",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import os\n",
    "from tqdm import tqdm\n",
    "import re\n",
    "from scipy import stats\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f3c91843",
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_answer(text):\n",
    "    pattern = r\"(True|False|Don't know)\"\n",
    "    matches = re.findall(pattern, text)\n",
    "    return matches\n",
    "\n",
    "def process_df(prompt_response_df, rag_response_df):\n",
    "    prompt_response_df.loc[:, \"answer_count\"] = prompt_response_df.extracted_answer.apply(lambda x:len(x))\n",
    "    prompt_response_df_multiple_answers = prompt_response_df[prompt_response_df.answer_count > 1]\n",
    "    prompt_response_df_single_answer = prompt_response_df.drop(prompt_response_df_multiple_answers.index)\n",
    "    prompt_response_df_single_answer.drop(\"answer_count\", axis=1, inplace=True)\n",
    "    prompt_response_df_multiple_answers_ = []\n",
    "    for index, row in prompt_response_df_multiple_answers.iterrows():\n",
    "        if row[\"extracted_answer\"][0] == row[\"extracted_answer\"][1]:\n",
    "            prompt_response_df_multiple_answers_.append((row[\"question\"], row[\"label\"], row[\"llm_answer\"], row[\"extracted_answer\"][0]))\n",
    "        else:\n",
    "            prompt_response_df_multiple_answers_.append((row[\"question\"], row[\"label\"], row[\"llm_answer\"], None))\n",
    "    prompt_response_df_multiple_answers_ = pd.DataFrame(prompt_response_df_multiple_answers_, columns=[\"question\", \"label\", \"llm_answer\", \"extracted_answer\"])\n",
    "    prompt_response_df_final = pd.concat([prompt_response_df_single_answer, prompt_response_df_multiple_answers_], ignore_index=True)\n",
    "    prompt_response_df_final = prompt_response_df_final.explode(\"extracted_answer\")\n",
    "\n",
    "    rag_response_df.loc[:, \"answer_count\"] = rag_response_df.extracted_answer.apply(lambda x:len(x))\n",
    "    rag_response_df_multiple_answers = rag_response_df[rag_response_df.answer_count > 1]\n",
    "    rag_response_df_single_answer = rag_response_df.drop(rag_response_df_multiple_answers.index)\n",
    "    rag_response_df_single_answer.drop(\"answer_count\", axis=1, inplace=True)\n",
    "    rag_response_df_multiple_answers_ = []\n",
    "    for index, row in rag_response_df_multiple_answers.iterrows():\n",
    "        if row[\"extracted_answer\"][0] == row[\"extracted_answer\"][1]:\n",
    "            rag_response_df_multiple_answers_.append((row[\"question\"], row[\"label\"], row[\"llm_answer\"], row[\"extracted_answer\"][0]))\n",
    "        else:\n",
    "            rag_response_df_multiple_answers_.append((row[\"question\"], row[\"label\"], row[\"llm_answer\"], None))\n",
    "    rag_response_df_multiple_answers_ = pd.DataFrame(rag_response_df_multiple_answers_, columns=[\"question\", \"label\", \"llm_answer\", \"extracted_answer\"])\n",
    "    rag_response_df_final = pd.concat([rag_response_df_single_answer, rag_response_df_multiple_answers_], ignore_index=True)\n",
    "    rag_response_df_final = rag_response_df_final.explode(\"extracted_answer\")\n",
    "    \n",
    "    prompt_incorrect_answers_because_of_na = prompt_response_df_final[prompt_response_df_final.extracted_answer.isna()]\n",
    "    rag_incorrect_answers_because_of_na = rag_response_df_final[rag_response_df_final.extracted_answer.isna()]\n",
    "\n",
    "    row_index_to_drop = list(prompt_incorrect_answers_because_of_na.index.values) + list(rag_incorrect_answers_because_of_na.index.values)\n",
    "\n",
    "    prompt_response_df_final.drop(row_index_to_drop, inplace=True)\n",
    "    rag_response_df_final.drop(row_index_to_drop, inplace=True)\n",
    "\n",
    "    prompt_response_df_final = prompt_response_df_final.reset_index()\n",
    "    rag_response_df_final = rag_response_df_final.reset_index()\n",
    "    response_transform = {\n",
    "        \"True\" : True,\n",
    "        \"False\" : False\n",
    "    }\n",
    "\n",
    "    prompt_response_df_final.extracted_answer = prompt_response_df_final.extracted_answer.apply(lambda x:response_transform[x])\n",
    "    rag_response_df_final.extracted_answer = rag_response_df_final.extracted_answer.apply(lambda x:response_transform[x])\n",
    "\n",
    "    return prompt_response_df_final, rag_response_df_final\n",
    "\n",
    "\n",
    "def evaluate(df):\n",
    "    correct = df[df.label == df.extracted_answer]\n",
    "    incorrect = df[df.label != df.extracted_answer]\n",
    "    correct_frac = correct.shape[0]/df.shape[0]\n",
    "    incorrect_frac = incorrect.shape[0]/df.shape[0]\n",
    "    return correct_frac, incorrect_frac\n",
    "\n",
    "\n",
    "def bootstrap(prompt_response_df_final, rag_response_df_final, niter = 1000, nsample = 150):\n",
    "    prompt_correct_frac_list = []\n",
    "    rag_correct_frac_list = []\n",
    "    for i in tqdm(range(niter)):\n",
    "        prompt_response_df_final_sample = prompt_response_df_final.sample(n=nsample, random_state=i)\n",
    "        prompt_correct_frac, prompt_incorrect_frac = evaluate(prompt_response_df_final_sample)\n",
    "        rag_response_df_final_sample = rag_response_df_final.iloc[prompt_response_df_final_sample.index]\n",
    "        rag_correct_frac, rag_incorrect_frac = evaluate(rag_response_df_final_sample)\n",
    "        prompt_correct_frac_list.append(prompt_correct_frac)\n",
    "        rag_correct_frac_list.append(rag_correct_frac)\n",
    "    return prompt_correct_frac_list, rag_correct_frac_list\n",
    "\n",
    "def plot_figure(prompt_correct_frac_list, rag_correct_frac_list):\n",
    "    fig = plt.figure(figsize=(5, 3))\n",
    "    ax = plt.gca()\n",
    "\n",
    "    sns.kdeplot(prompt_correct_frac_list, color=\"blue\", shade=True, label=\"Prompt based\", ax=ax, lw=2, linestyle=\"-\", alpha=0.6)\n",
    "    sns.kdeplot(rag_correct_frac_list, color=\"lightcoral\", shade=True, label=\"KG-RAG based\", ax=ax, lw=2, linestyle=\"-\", alpha=0.6)\n",
    "\n",
    "    for artist in ax.lines:\n",
    "        artist.set_edgecolor(\"black\")\n",
    "\n",
    "    plt.xlabel(\"Accuracy\")\n",
    "    plt.ylabel(\"Density\")\n",
    "    plt.legend(loc=\"upper left\")\n",
    "    plt.xlim(0.75,1)\n",
    "\n",
    "    ax.axvline(np.mean(prompt_correct_frac_list), color='black', linestyle='--', lw=2)\n",
    "    ax.axvline(np.mean(rag_correct_frac_list), color='black', linestyle='--', lw=2)\n",
    "\n",
    "    sns.despine(top=True, right=True)\n",
    "\n",
    "    plt.show()\n",
    "    return fig\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a5723e54-a5ef-48cd-85d1-88d0fe7ea78e",
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "Following files can be obtained by running the run_true_false_generation.py script.\n",
    "Make sure to change the parent path and filenames based on where and how you save the files\n",
    "'''\n",
    "\n",
    "data_path ='../data/results'\n",
    "\n",
    "llama_prompt_path = os.path.join(data_path, 'Llama_2_13b_chat_hf_prompt_based_true_false_binary_response.csv')\n",
    "llama_kg_rag_path = os.path.join(data_path, 'Llama_2_13b_chat_hf_PubMedBert_and_entity_recognition_based_node_retrieval_rag_based_true_false_binary_response.csv')\n",
    "\n",
    "gpt_35_prompt_path = os.path.join(data_path, 'gpt_35_turbo_prompt_based_true_false_binary_response.csv')\n",
    "gpt_35_kg_rag_path = os.path.join(data_path, 'gpt_35_turbo_PubMedBert_and_entity_recognition_based_node_retrieval_rag_based_true_false_binary_response.csv')\n",
    "\n",
    "gpt_4_prompt_path = os.path.join(data_path, 'gpt_4_prompt_based_true_false_binary_response.csv')\n",
    "gpt_4_kg_rag_path = os.path.join(data_path, 'gpt_4_PubMedBert_and_entity_recognition_based_node_retrieval_rag_based_true_false_binary_response.csv')\n",
    "\n",
    "curated_data = pd.read_csv('../data/benchmark_data/true_false_questions.csv').drop('Unnamed: 0', axis=1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "47f3c405",
   "metadata": {},
   "outputs": [],
   "source": [
    "llama_prompt_df = pd.read_csv(llama_prompt_path)\n",
    "llama_prompt_df = pd.merge(curated_data, llama_prompt_df, left_on='text', right_on='question').drop(['text', 'label_y'], axis=1).rename(columns={'label_x':'label'})\n",
    "\n",
    "llama_kg_rag_df = pd.read_csv(llama_kg_rag_path)\n",
    "llama_kg_rag_df = pd.merge(curated_data, llama_kg_rag_df, left_on='text', right_on='question').drop(['text', 'label_y'], axis=1).rename(columns={'label_x':'label'})\n",
    "\n",
    "gpt_35_prompt_df = pd.read_csv(gpt_35_prompt_path)\n",
    "gpt_35_prompt_df = pd.merge(curated_data, gpt_35_prompt_df, left_on='text', right_on='question').drop(['text', 'label_y'], axis=1).rename(columns={'label_x':'label'})\n",
    "\n",
    "gpt_35_kg_rag_df = pd.read_csv(gpt_35_kg_rag_path)\n",
    "gpt_35_kg_rag_df = pd.merge(curated_data, gpt_35_kg_rag_df, left_on='text', right_on='question').drop(['text', 'label_y'], axis=1).rename(columns={'label_x':'label'})\n",
    "\n",
    "gpt_4_prompt_df = pd.read_csv(gpt_4_prompt_path)\n",
    "gpt_4_prompt_df = pd.merge(curated_data, gpt_4_prompt_df, left_on='text', right_on='question').drop(['text', 'label_y'], axis=1).rename(columns={'label_x':'label'})\n",
    "\n",
    "gpt_4_kg_rag_df = pd.read_csv(gpt_4_kg_rag_path)\n",
    "gpt_4_kg_rag_df = pd.merge(curated_data, gpt_4_kg_rag_df, left_on='text', right_on='question').drop(['text', 'label_y'], axis=1).rename(columns={'label_x':'label'})\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "0ca02159",
   "metadata": {},
   "outputs": [],
   "source": [
    "llama_prompt_df.loc[:, 'extracted_answer'] = llama_prompt_df['llm_answer'].apply(extract_answer)\n",
    "llama_kg_rag_df.loc[:, 'extracted_answer'] = llama_kg_rag_df['llm_answer'].apply(extract_answer)\n",
    "\n",
    "gpt_35_prompt_df.loc[:, 'extracted_answer'] = gpt_35_prompt_df['llm_answer'].apply(extract_answer)\n",
    "gpt_35_kg_rag_df.loc[:, 'extracted_answer'] = gpt_35_kg_rag_df['llm_answer'].apply(extract_answer)\n",
    "\n",
    "gpt_4_prompt_df.loc[:, 'extracted_answer'] = gpt_4_prompt_df['llm_answer'].apply(extract_answer)\n",
    "gpt_4_kg_rag_df.loc[:, 'extracted_answer'] = gpt_4_kg_rag_df['llm_answer'].apply(extract_answer)\n",
    "\n",
    "llama_prompt_df, llama_kg_rag_df = process_df(llama_prompt_df, llama_kg_rag_df)\n",
    "\n",
    "gpt_35_prompt_df, gpt_35_kg_rag_df = process_df(gpt_35_prompt_df, gpt_35_kg_rag_df)\n",
    "\n",
    "gpt_4_prompt_df, gpt_4_kg_rag_df = process_df(gpt_4_prompt_df, gpt_4_kg_rag_df)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "90ccd105",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:00<00:00, 1323.05it/s]\n",
      "100%|█████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:00<00:00, 1207.89it/s]\n",
      "100%|█████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:00<00:00, 1168.13it/s]\n"
     ]
    }
   ],
   "source": [
    "llama_prompt_correct_frac_list, llama_rag_correct_frac_list = bootstrap(llama_prompt_df, llama_kg_rag_df)\n",
    "\n",
    "gpt_35_prompt_correct_frac_list, gpt_35_rag_correct_frac_list = bootstrap(gpt_35_prompt_df, gpt_35_kg_rag_df)\n",
    "\n",
    "gpt_4_prompt_correct_frac_list, gpt_4_rag_correct_frac_list = bootstrap(gpt_4_prompt_df, gpt_4_kg_rag_df)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "428528e7",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/p1/h56gxdhs5vgb0ztp7h4z606h0000gn/T/ipykernel_52094/309868377.py:80: FutureWarning: \n",
      "\n",
      "`shade` is now deprecated in favor of `fill`; setting `fill=True`.\n",
      "This will become an error in seaborn v0.14.0; please update your code.\n",
      "\n",
      "  sns.kdeplot(prompt_correct_frac_list, color=\"blue\", shade=True, label=\"Prompt based\", ax=ax, lw=2, linestyle=\"-\", alpha=0.6)\n",
      "/var/folders/p1/h56gxdhs5vgb0ztp7h4z606h0000gn/T/ipykernel_52094/309868377.py:81: FutureWarning: \n",
      "\n",
      "`shade` is now deprecated in favor of `fill`; setting `fill=True`.\n",
      "This will become an error in seaborn v0.14.0; please update your code.\n",
      "\n",
      "  sns.kdeplot(rag_correct_frac_list, color=\"lightcoral\", shade=True, label=\"KG-RAG based\", ax=ax, lw=2, linestyle=\"-\", alpha=0.6)\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAdYAAAEmCAYAAADfiLFDAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAA9hAAAPYQGoP6dpAABcPklEQVR4nO3deXgT1foH8O8kadKk+0pX2mKhyL7Jrogii6IgoijiFZR73S4K/LhcFUXUCwgKcl1AVCigbAoWuYJABVpAZG8BLWsptJSWQulCtzTL+f0xzSTpQts0yWR5P8+Th0kymTkdpn1ztvdwjDEGQgghhFiFROwCEEIIIa6EAishhBBiRRRYCSGEECuiwEoIIYRYEQVWQgghxIoosBJCCCFWRIGVEEIIsSIKrIQQQogVuXxgZYyhtLQUlAeDEEKIPcjELoCt3b59G35+figpKYGvr6/YxSHEZS1evBilpaXw9fXF9OnTxS6OQ6Nr5do4V09pWFpaSoGVEDuIiopCbm4uIiMjcfXqVbGL49DoWrk2l28KJoQQQuyJAishhBBiRRRYCSGEECuiwEoIIYRYkcuPCm4Kxhi0Wi10Op3YRSEuwMPDA1KpVOxiEEJE4vaBtbq6Gnl5eaioqBC7KMRFcByHqKgoeHt7i10UQogI3Dqw6vV6ZGVlQSqVIiIiAnK5HBzHiV0s4sQYY7hx4wauXr2Ktm3bUs2VEDfk1oG1uroaer0e0dHRUKlUYheHuIiQkBBcvnwZGo2GAishbsitA6uBREJjuIj1uGurxyOPPIJbt24hMDBQ7KI4vOG9e+PmhQsIUChQ/t13UI4eDYmPj9jFIlZCgZUQYhXLly8XuwhOQZORgUVduwJduwIAtJcuoWLDBnhNmgRORn+SXQFV1QghxE5YdTUqt2+v87ru2jWo9+8XoUTEFujrUT169QLy8+17zrAw4Ngx+57T0aSkpGDw4MEoKiqCv7+/2MURXL58GXFxcUhLS0O3bt3ELg5xYupDh8DKywEAnJ8fpOHh0J49y7/3+++Qd+sGSUCAmEUkVkCBtR75+UBurtilaNjEiROxevVqAIBMJkN0dDTGjBmD999/H15eXiKXri4KTIQATKNB9eHDwnNZZCQ4T09IQkOhLygAdDpU7d4N1dixIpaSWAMF1jvgOMDWg4UrKgBL1hcaPnw4EhMTodFosH//fkyePBnl5eVYtmxZnX01Gg08PDysUFpCGtarVy/k5+cjLCwMx9y9+aUe1enpYDXz5QevWIHrFRVoFRCAAx9/DP2tW4BWC81ff0HbsydkcXEil5a0BPWx3oFKBTz7rG0flgZuhUKBsLAwREdHY/z48Xj22WexZcsWAMCcOXPQrVs3rFy5Em3atIFCoQBjDNnZ2Rg1ahS8vb3h6+uLp556CtevXxeOafq51q1bw9vbG6+88gp0Oh0WLlyIsLAwhIaGYu7cuWZl4TgOy5Ytw4gRI6BUKhEXF4cff/xReD+u5o9E9+7dwXEc7r///jv+bL///ju6du0KT09P9OnTB6dPnxbeKywsxDPPPIOoqCioVCp07twZ69evN/v8pk2b0LlzZyiVSgQFBWHIkCEor2l+A4DExETcfffd8PT0RPv27bF06VKzzx85cgTdu3eHp6cnevXqhbS0tMb/Qwjy8/ORm5uLfHv3ozgBptej+o8/hOfXy8txrbAQ14uKwEmlkEZECO9VbN0KPSWscWoUWF2EUqmERqMRnl+8eBE//PADNm/ejPT0dADA6NGjcevWLaSmpiI5ORmZmZkYN26c2XEyMzPx66+/YseOHVi/fj1WrlyJRx55BFevXkVqaioWLFiAd955B4cOHTL73LvvvosnnngCJ0+exIQJE/DMM8/gzJkzAPhABQC//fYb8vLy8NNPP93xZ/nXv/6FTz75BEePHkVoaCgee+wx4WerqqpCz5498csvv+DPP//EP/7xDzz33HM4XNPElpeXh2eeeQYvvPACzpw5g5SUFIwZMwaGZYe/+eYbzJo1C3PnzsWZM2cwb948vPvuu0LTenl5OUaOHImEhAQcP34cc+bMwYwZMyz5LyFEoPnrL+iLigAAnI8P3xxmQhIUBK6mG4cVF6M8MRHaS5fg4stluyxqCnYBR44cwbp16/Dggw8Kr1VXV+O7775DSEgIACA5ORmnTp1CVlYWoqOjAQDfffcdOnbsiKNHj+Kee+4BwGejWrlyJXx8fNChQwcMHjwY586dw/bt2yGRSJCQkIAFCxYgJSUFffv2Fc735JNPYvLkyQCADz/8EMnJyfj888+xdOlSoQxBQUEICwtr9Od577338NBDDwEAVq9ejaioKCQlJeGpp55CZGSkWaCbMmUKduzYgR9//BF9+vRBXl4etFotxowZg5iYGABA586dhf0//PBDLFq0CGPGjAHA16YzMjKwfPlyPP/881i7di10Oh1WrlwJlUqFjh074urVq3jllVea+b9CCI9pNFDv3Ss8l9bzO8BxHGRxcdCcPQtotdDfvIny776DNDoaqjFjIHGgwXykcVRjdVK//PILvL294enpiX79+uG+++7D559/LrwfExMjBDQAOHPmDKKjo4WgCgAdOnSAv7+/ULMEgNjYWPiYTFRv1aoVOnToYJZEo1WrVigoKDArT79+/eo8Nz1uc5geKzAwEAkJCcKxdDod5s6diy5duiAoKAje3t7YtWsXsrOzAQBdu3bFgw8+iM6dO+PJJ5/EN998g6KamsKNGzeQk5ODF198Ed7e3sLjP//5DzIzM4Xr1LVrV7NMXLV/NkKaijGGquRks9pqQ4kgOLkcHgkJ4JRK4TVdTg7KVq6kpmEnQzVWJzV48GAsW7YMHh4eiIiIqDM4qfboYMZYvRmBar9e+zgcx9X7ml6vb7SM1sxAZDjWokWL8Omnn2LJkiXo3LkzvLy8MHXqVFRXVwMApFIpkpOTcfDgQezatQuff/45Zs2ahcOHDwvB8ptvvkGfPn3Mjm9IPUhNb8Ra9BUVqEpOhqamKwYcB2lU1B0/wykUkLVvD31REXTXrgHV1WC3b6Nqxw6oalpZiOOjGquT8vLyQnx8PGJiYpo04rdDhw7Izs5GTk6O8FpGRgZKSkpw9913t7g8tftcDx06hPbt2wMA5HI5ADR5WT7TYxUVFeH8+fPCsfbv349Ro0ZhwoQJ6Nq1K9q0aYMLFy6YfZ7jOAwYMADvv/8+0tLSIJfLkZSUhFatWiEyMhKXLl1CfHy82cMwwKpDhw44efIkKisrG/zZCGmM9tIllH3xhTGoApBGR0NiUhttCMdxkAYGwqNdO6DmC5/mzz+hLy62UWmJtYlaY50/fz5++uknnD17FkqlEv3798eCBQuQkJAg7GM6Z9OgT58+dvljV1EBrF1r+3PYw5AhQ9ClSxc8++yzWLJkCbRaLV599VUMGjQIvXr1avHxf/zxR/Tq1QsDBw7E2rVrceTIEaxYsQIAEBoaCqVSiR07diAqKgqenp7w8/Nr8FgffPABgoKC0KpVK8yaNQvBwcEYPXo0ACA+Ph6bN2/GwYMHERAQgMWLFyM/P1/4cnD48GHs3r0bQ4cORWhoKA4fPowbN24I78+ZMwevv/46fH19MWLECKjVahw7dgxFRUWYPn06xo8fj1mzZuHFF1/EO++8g8uXL+OTTz5p8fUh7kN79SrK164FDK06Egmk0dGQBgU16zicXA5paCh0eXkAY6g+fhyeJuMoiOMStcaampqK1157DYcOHUJycjK0Wi2GDh1qNjUC4Ods5uXlCY/t9aQEswXGgPJy2z7s1fLIcRy2bNmCgIAA3HfffRgyZAjatGmDjRs3WuX477//PjZs2IAuXbpg9erVWLt2LTp06ACAT2Lx2WefYfny5YiIiMCoUaPueKyPPvoIb7zxBnr27Im8vDxs3bpVqPW+++676NGjB4YNG4b7778fYWFhQtAFAF9fX+zbtw8PP/ww2rVrh3feeQeLFi3CiBEjAACTJ0/Gt99+i1WrVqFz584YNGgQVq1aJdRYvb298b///Q8ZGRno3r07Zs2ahQULFljlGhHXx3Q6VCYlCUGV8/WFR4cOzQ6qBpLgYGFbk5FhlTIS2+OYA3Uq3bhxA6GhoUhNTcV9990HgK+xFhcXC3M0m6u0tBR+fn4oKSmBr6+v2XtVVVXIyspCXFwcPD09hdcppWHzcByHpKQkswDnzhq6r1xdVFQUcnNzERkZiatXr4pdHFFUnzyJypq/VZxKBVlCQr1jDeInTcK1wkJEBAXhYmLiHY+pOX8erKwMAOA9ZQqktHqQw3OowUslJSUAUGfZqZSUFISGhsLf3x+DBg3C3LlzERoaWu8x1Go11Gq18Ly0tLTZ5XDWAEeImBYuXIiKigq3XttYbdJFJY2KanAA39yJE1GhVkOlUDR6TImvL3Q1gVV74QKktQbeEcfjMIGVMYbp06dj4MCB6NSpk/D6iBEj8OSTTyImJgZZWVl499138cADD+D48eNQ1HNTzp8/H++//749i04IATB+/HixiyAq3c2b0Nc0dXEqlZDwoT7jBg1q8nE5X1/g2jUAgDY7GwoKrA7PYQLrP//5T5w6dQoHDhwwe900M1CnTp3Qq1cvxMTEYNu2bcIkf1NvvfUWpk+fLjwvLS01m7tJrM+BehMIEY3GZN62JCDAatPNOKUSkEgAvR46N21idzYOEVinTJmCrVu3Yt++fYhqZJ5XeHg4YmJi6kyxMFAoFPXWZAkhxJa0584J29bMlMRxHDiVCqysDKy0FPrSUkhqjRchjkXUwMoYw5QpU5CUlISUlBRhZOadFBYWIicnB+Hh4XYoISGkqc6dOwetVguZTGY2Zc4dsKoqPqEDAM7TE1wjX+7PX70KrV4PmUSCdo1UJgCA8/ISBjDpcnMpsDo4UQPra6+9hnXr1uHnn3+Gj4+PsCqGn58flEolysrKMGfOHDzxxBMIDw/H5cuX8fbbbyM4OBiPP/64mEUnhNTy4IMPuu2oYO2VK8LcOa6BlIWmHn733SaPCgYAiZcXDLnOdHl58LBCUhdiO6IGVsPaobWXEUtMTMTEiRMhlUpx+vRprFmzBsXFxQgPD8fgwYOxceNGs3y2hBAiJu3ly8J2Q7mAW8Isf7DJUo/EMYneFHwnSqUSO3futFNpCCHEMjqTVKGct7f1TyCXGwcwUWB1eA4xeMnRlH39NfQ1/Rn2IvH2hvc//mHXczq6VatWYerUqSh2sBypKSkpGDx4MIqKiuBPy3m5PabV8mkHAUChACez/p9VjuPAKZVg5eVgJSVglZVmtVjiWCgJfz30ZWVgt2/b9dGcQD5x4sQ6WY42bdoET09PLFy4UHittLQU7777Ljp27AilUomgoCDcc889WLhwobCUWkNiY2P5X2aOg1KpRPv27fHxxx/X28pw8OBBSKVSDB8+vN5jVVdX4+OPP0aPHj3g5eUFPz8/dO3aFe+88w6u1Qz4IMRZ6fLyhBSGElvUVmtwJok3dLWWbSSOhWqsjWnCyjEtotG0+BDffvstXnvtNXz55ZfCYuO3bt3CwIEDUVpaig8//BA9e/aEXC7HxYsXsW7dOqxbtw6vvfbaHY/7wQcf4O9//zuqqqrw22+/4ZVXXoGvry9eeukls/1WrlyJKVOm4Ntvv0V2djZat24tvKdWqzF06FCcOnUK77//PgYMGAA/Pz9kZmZiy5Yt+PzzzzF//vwWXwNCxGI6t/ROSSFaijNJj6krKIAsJsZm5yItQ4H1Tjw8IO/c2aanqD59ukXBdeHChZg9ezbWrVuHJ554Qnj97bffRnZ2Ns6dO4fIyEjh9fbt22PkyJFNSurg4+ODsLAwAHzy+mXLlmHXrl1mgbW8vBw//PADjh49ivz8fKxatQqzZ88W3v/0009x4MABHDt2DN27dxdej4+Px7Bhw5pUji1btmDmzJnIzs7Gvffei5UrVwpJPzIzMzF9+nQcOnQI5eXluPvuuzF//nwMGTJE+PzSpUvx6aefIicnB35+frj33nuxadMmAHw//8cff4yvvvoKeXl5aNeuHd59912MHTtW+Pz27dsxdepU5OTkoG/fvnj++ecbLTNxH7rcXGGbs2E6R9PAqr9xw2bnIS1HTcFO7M0338SHH36IX375xSyo6vV6bNy4ERMmTDALqqaakxWGMYaUlBScOXOmztqvGzduREJCAhISEjBhwgQkJiaaBcv169fjoYceMguqzSlHRUUF5s6di9WrV+P3339HaWkpnn76aeH9srIyPPzww/jtt9+QlpaGYcOG4dFHH0V2djYA4NixY3j99dfxwQcf4Ny5c9ixY4ewwAMAvPPOO0hMTMSyZcvw119/Ydq0aZgwYQJSU1MBADk5ORgzZgwefvhhpKenY/LkyXjzzTebfO2I69MaAmtNP6itmI0MvnnTZuchLUeB1Un9+uuvWLBgAX7++Wez2hnArxJUXFxcZ5J+z5494e3tDW9vbzzzzDONnuPf//43vL29oVAoMHjwYDDG8Prrr5vts2LFCkyYMAEAv7xfWVkZdu/eLbx//vz5OuV4/PHHhXL079//jmXQaDT44osv0K9fP/Ts2ROrV6/GwYMHceTIEQBA165d8dJLL6Fz585o27Yt/vOf/6BNmzbYunUrACA7OxteXl4YOXIkYmJi0L17d+FnKC8vx+LFi7Fy5UoMGzYMbdq0wcSJEzFhwgQsX74cAD8lrE2bNvj000+RkJCAZ599FhMnTmz02hH3oK+oAKsZXMepVFZLY1gfTiYDagZG6amP1aFRYHVSXbp0QWxsLGbPno3bt2/Xu0/tX/KkpCSkp6dj2LBhqKysBADMmzdPCHLe3t5CTQ8A/vWvfyE9PR2pqakYPHgwZs2aZRYIz507hyNHjgg1SJlMhnHjxmHlypV3LMfSpUuRnp6OF154ARWNrPQuk8nMFmJv3749/P39caYmL2t5eTlmzpyJDh06wN/fH97e3jh79qzwczz00EOIiYlBmzZt8Nxzz2Ht2rXCOTMyMlBVVYWHHnrI7BqsWbMGmZmZAIAzZ86gb9++Zj9Dv3797lhm4j7MmoFt2L8qnKOmOZiVl0PfyO8OEQ/1sTqpyMhIbN68GYMHD8bw4cOxY8cOIWlGSEgI/P39cfbsWbPPGAYV+fj4CFNYXn75ZTz11FPCPhEREcJ2cHAw4uPjER8fj82bNyM+Ph59+/YVasgrVqyAVqs1a25mjMHDwwNFRUUICAhA27Zt65TDkI6y9vKADamvFmB47V//+hd27tyJTz75BPHx8VAqlRg7diyqq6uFn/XEiRNISUnBrl27MHv2bMyZMwdHjx6FvmYk57Zt2+o0mRvyTdMCA0139OhR6HQ6SKVSsYtiNzqTUe3N6V/dv2gRdHo9pJLm1W04T08htaH+5k1ITAYKEsdBNVYn1rp1a6SmpqKgoABDhw4V1p6VSCR46qmn8P333yPX5Bt1fQIDA4XgGR8fD1kDc/ACAgIwZcoUzJgxA4wxaLVarFmzBosWLUJ6errwOHnyJGJiYrB27VoAwDPPPIPk5GSkpaVZ9DNqtVocM1kg99y5cyguLkb79u0BAPv378fEiRPx+OOPo3PnzggLC8Nlkyw4AF/rHTJkCBYuXIhTp07h8uXL2LNnDzp06ACFQoHs7GyzaxAfHy8MjurQoQMOmayxCaDOc8ILDw9HVFSUW+XxNg2skmbUWMMDAxEVHIzwZi5abjaAifpZHRYFVicXFRWFlJQUFBYWYujQocJi8fPmzUNkZCT69OmDlStX4tSpU8jMzERSUhL++OMPi2oVr732Gs6dO4fNmzfjl19+QVFREV588UV06tTJ7DF27FisWLECADBt2jT069cPDzzwAP773//ixIkTyMrKws6dO/Hrr782Wg4PDw9MmTIFhw8fxokTJzBp0iT07dsXvXv3BsCPLv7pp5+EoD5+/HihJgoAv/zyCz777DOkp6fjypUrWLNmDfR6PRISEuDj44MZM2Zg2rRpWL16NTIzM5GWloYvv/wSq1evBsDX6A0jj8+dO4d169Zh1apVzb52xPUwxoxNwVIpnx3Jxsym3NDIYIdFTcF3otHw02FsfI6WioyMFPpBH3roIezatQtBQUE4cuQIFixYgI8//hhZWVmQSCRo27Ytxo0bh6lTpzb7PCEhIXjuuecwZ84cxMXFYciQIfDz86uz3xNPPIF58+bhxIkT6NGjB3bv3o0lS5YgMTERb731FvR6PeLi4jBixAhMmzbtjudUqVT497//jfHjx+Pq1asYOHCgWR/up59+ihdeeAH9+/dHcHAw/v3vfws1dwDw9/fHTz/9hDlz5qCqqgpt27bF+vXr0bFjRwDAhx9+iNDQUMyfPx+XLl2Cv78/evTogbfffhsA3yqwefNmTJs2DUuXLkXv3r0xb948vPDCC82+fsS1sNJSsPJyALYfuGRANVbnwDEX70QqLS2Fn58fSkpK4FtrqaWqqipkZWUhLi4OniY3bOnixWANDAiyFc7HB74mC7QT59XQfeXqvv76a5SVlcHb2xv/cIP0nNV//YXKmvnQkrAwyEzGJzRmxY4dKK+qgpenJ15sIGNZfRhj0Jw8Cej14Pz94fvGG80uN7E9qrHWQ+LtDX3ju1n9nIQ4sw8++EBYNs4dAqtpxqXm9K8CwPyNG4Vl45oTWDmO4wcw1UzzYdXV4OzQBE2ahwJrPSgZPiGkMfZKZVibIbACgL6wEFI3GizmLGjwEiHEqoqLgTFjgDfeAGw9REEs9ljRpiE0gMnxUWAlhLTYrVtAYSG/XV4OJCUBn30GdOkCvPWWsPiLy9BduwbodACa3wzcUqapDSlnsGOiwEoIaZHCQmDwYKCqqv73P/oIeOUVwJWGSWpNMpTZZGHzOzCrsdLIYIdEgRWUXYdYlzvdT2o1MHIkcOqU8TW5HBg3DujVCzDMQPn6a6Am/bJL0JkEVrsPPJTLhQtLNVbH5NaB1bBSS2P5aglpDkM6RXdI7Td9OmBIRGUIoh4egJ8f0KMHcP/9xn2nTQOysuxeRKtjer2xxiqTATXpL+3FMDIYAPS3boFZYS48sS63HhUslUrh7++PgpqVIlR2muRNXJder8eNGzegUqkaTA/pKnbsAJYu5belUj6g1m4ObtsWuH4dyMjg3/vnP4Ft2+xfVmvS5+fzVXXwzcBi/M3glEqwykqAMehv3qSRwQ7GtX/zm8CwkHcBLcNErEQikaB169Yu/SWtrAwwnZXWrx/QUDro3r2By5eBigpg+3Zg716+T9ZZaU1yUUtqFr6wN7O1WQsKKLA6GLcPrBzHITw8HKGhodBQkwqxArlcDkkzVy1xNvPnAzk5/HZkJHD33cClS+0gl/tBqWxltq9czgfXlBT++ezZwL59xqZjZ2MWWC3sX20bEQE/lQqh/v4Wfd5sABNVChyO2wdWA6lU6hZ9YoS01OXLwKJF/LZEAgwcyAfJkSP3NPiZ+HggPZ2f43rgAJCaat7/6iyYTgftlSv8E5kMsDBl5a9z57aoHGZTbq5fb9GxiPW59tdqQojVzZkjdDGic2d+oFJjJBJ+MJPBkiW2KJnt6fLygJrBaRIfH/Ga+z08+I5tALr8fHHKQBpEgZUQ0mRnzwLffcdvKxRA9+5N/2ybNoAhl8LWrcDFi9Yvn61pTYY1cyL1rwI1I4NrFlZn5eXQ1yx+ThwDBVZCSJPNnWvMotS1a/OWIJVIgJrV+sAYP7fV2egMzcAQf+EMswFMVGt1KBRYCSFNkpUFrF/PbysUxiBpsGfPs9i+fRj27Hm2wWMkJPABFgBWrRJaVZ0C0+uhNYzY8vBo0fzVSYsW4bH33sMkQ2e1BSiwOi4avEQIaZJFi4T0uOjUiY8tpvLyUlFengsvr8gGj6FUArGxwKVLwI0bfJPw2LG2K7M16fLzjf2rLZy/uv/PP4Vl4ywlUamgM5TNsCAAcQhUYyWENKq4mK9hAvxg2Nq11eZo3964vWZNS0plXzpDbRX2zw9cL09Pofqvu3ZN5MIQUxRYCSGNWrGCX7UGANq1s3iWCQB+3qthENOvvwLOkkdel5srbNtz/dWGcBwnNAez4mLoKytFLhExEDWwzp8/H/fccw98fHwQGhqK0aNH49y5c2b7MMYwZ84cREREQKlU4v7778dff/0lUokJcT96PfDll8bnnTq17HgcB9x1F7+t1QI//NCy49mLsLC5SUATm2FkMEC1VkciamBNTU3Fa6+9hkOHDiE5ORlarRZDhw5FueGrMYCFCxdi8eLF+OKLL3D06FGEhYXhoYcewu3bt0UsOSHuIznZmDw/KgqwMFmQmbZtjduGAVGOTF9RAX1REQA+mDlKukoKrI5J1MFLO3bsMHuemJiI0NBQHD9+HPfddx8YY1iyZAlmzZqFMWPGAABWr16NVq1aYd26dXjppZfEKDYhbuWrr4zbHTpY55iBgXyALi4Gfv8duHYNiIiwzrFtwXRwkGkwE5vEy8s4gMmkqZqIy6H6WEtKSgAAgYGBAICsrCzk5+dj6NChwj4KhQKDBg3CwYMH6z2GWq1GaWmp2YMQYpn8fOB//+O3VSqgdWvrHJfj+IQRAD+n9aefrHNcWzFNG+hIgRUKBQ1gckAOE1gZY5g+fToGDhyITjWdOPk1c7NatTJP6t2qVSvhvdrmz58PPz8/4REdHW3bghPiwr77zjjFxnQOqjXExRm3N22y3nFtQWcaWB2kfxWoGcBUM5CK3b4NPVUkHILDBNZ//vOfOHXqFNbX0+FSuz+DMdZgH8dbb72FkpIS4ZFjMkSeENJ0jAErVxqft2tn3eMHBhrzDO/f79ijg80Ca0uGRNsA9bM6HodIEDFlyhRs3boV+/btQ1RUlPC6Ya3U/Px8hJusN1hQUFCnFmugUCigaEFGFEII79gxPjcwAISFNZ5sv337v6O6ugRyeROy8oNvDo6JAU6d4kceb9sGPP98CwttA0yng/7GDQB8UOWsUG2fNHQoSisq4GuFZmWJSoWaLJPQ5ebCw3SiMBGFqIGVMYYpU6YgKSkJKSkpiDNtGwIQFxeHsLAwJCcno3tNtu/q6mqkpqZiwYIFYhSZELfx/ffG7abUVnv2fK/Z54iN5QMrAPz8s2MGVn1RkZAg2Vq11VnPPGOV4wDmc2qpxuoYRA2sr732GtatW4eff/4ZPj4+Qr+pn58flEolOI7D1KlTMW/ePLRt2xZt27bFvHnzoFKpMH78eDGLTohL02iM02CkUuNAI2sLDeWTTVRVATt38v86WEsr9IWFxieOVjiAzy0pkwFaLXTXrt2xq4zYh6iBddmyZQCA+2uteJyYmIiJEycCAGbOnInKykq8+uqrKCoqQp8+fbBr1y74iLhkEyGubvduPpcvwDfXNmcVm+aQSPiRxufPAxUVwL59gMkkAIegN+n8dbT+VcC4hBwrLQWrqgIrKQFnjcnGxGKiNwU3huM4zJkzB3PmzLF9gQghAIANG4zb8fG2PZchsAJ8P6ujBVadSY2Vc9DxG4bACvBzbiUUWEXlMKOCCSGOoaoKSEritz08+GxLTbF2bRS+/prD2rVN/ECNqCh+IBMAbN/erI/ahS1qrPGTJkH12GOInzTJKseTmI4MppVuREeBlRBiZudOwDAdMjaW776zJbmcH3UMABcvAhcu2PZ8zaW/dYvfkMnASaXiFqYBHAVWh0KBlRBiZvNm47YhWb6tmeZx2bnTPudsClZdDVaTu9xRm4EB8E0LNUHfdM4tEQcFVkKIoLqaX3wc4P9WRza8ZrlVmTY3O1Jg1RcXC9uOHFjNlpC7fRv6igqRS+TeKLASQgR79gA1KbsREyNUgmwuKAgwZArcu5cP8I7AsKINANsNjbYS01SL+oICEUtCKLASQgSGQUuAeS5fW+M4Y621vJxf8cYRmAZWR66xAuaBlZqDxUWBlRACgE8uZFjJRipt+mhgazE932+/2ffcDaHASixBgZUQAgA4fhwwDCiNjOT7WO3JtD83Odm+526IWR+rozcFm0wF0jvyigZugAIrIQQAn6vXICbG/udXqfgVbwB+AQDT7k2x6A0dzhxn/28azcRJpUIZ9TduNCkBD7ENCqyEEADAL78Yt8UIrICx1soYP5BKbEJg9fBwivy7hlorq6oSpgkR+3OIZeMIIeLKzQVOnuS3Q0L42mNzDR78PXQ6NaRSy/siIyOB06f57d27gSeesPhQLcbUaj4NFazfDLxy+nSoNRoorFwL5jw9wW7fBsDXWiXe3lY9PmkaCqyEELNUgqbJGpojIuL+FpcjPJxvdWWMD6xiEmqrsH5gva9zZ6sez8C0n1V34wZk9hzaTQTUFEwIMQusrVuLVw4PD34pOYBPzH/1qnhlMQ2sjj6H1cBsAJPpcnfEriiwEuLmNBpj7dDTk28KFpPp6GAxa622rLHaillgNeQ4JnZHgZUQN/fHH0BNt5zZSjPNde1aCnJyduLatZQWlcdRAiszDaxW7gvdd/o0kk+cwD5Dh7K1yGT8IregGquYqI+VEDdnmpu3JUkh9u6dgPLyXHh5ReLZZy1vww0N5RNU6HR8ekPGLA/2LaE3fNuA9WusLyxejGuFhYgICsLFxESrHZfjOH4AU0UF9MXFYFotOFsvT0TqoBorIW7OWoHVWqRSfhATwPexXrwoTjn0hrXzAKfpYwVMMkQxZp7rmNgNBVZC3FhhIXDiBL8dGGjZNBtbiIgwbos1n5UZAqtEIjSvOgWT1IvUHCwOi+6WrKwsa5eDECICQ1Mr4Bi1VQPTwCpGPytjzFhjdZLkEAamOY1pAJM4LAqs8fHxGDx4ML7//ntU1UygJoQ4H9Nk96bBTGzBwcYMgikpxuBvN2o1P1wazjMi2IBGBovPosB68uRJdO/eHf/3f/+HsLAwvPTSSzhy5Ii1y0YIsTFDbVAiMfZrOgLT8ty4Afz1l33Pb9q/au0RwbZmVmOlPlZRWBRYO3XqhMWLFyM3NxeJiYnIz8/HwIED0bFjRyxevBg3btywdjkJIVaWnW0cGBQa6ng55sXsZ3XWgUsA+NFfNSvU66jGKooW9cjLZDI8/vjj+OGHH7BgwQJkZmZixowZiIqKwt/+9jfkGdagIoQ4HNNg5UjNwAam81n37rXvuZkz11g5Tqi1spISMK1W5BK5nxYF1mPHjuHVV19FeHg4Fi9ejBkzZiAzMxN79uxBbm4uRo0aZa1yEkKszDRYmQYxRxEYaBzgmpLCz2u1F7M5rE4WWIFaU25M1pQl9mFRYF28eDE6d+6M/v3749q1a1izZg2uXLmC//znP4iLi8OAAQOwfPlynDCM4yeEOBTGjIFVKjXm53UkHGesSRcXG1ffsQfmzE3BgFmZqZ/V/ixKybFs2TK88MILmDRpEsLCwurdp3Xr1lixYkWLCkcIsY1Ll4CcHH47LEzokmuRlmRbakhEBGCY3bdnD9Cjh9VPUS99WZmwbYsaqzWzLdWHptyIy6LAmpycjNatW0NSa9I0Yww5OTlo3bo15HI5nn/+easUkhBiXSkpxm1HGg1cm2nf7969wIwZ9jmv2eAlJ0wJSCODxWVRU/Bdd92Fmzdv1nn91q1biKP1/whxeKaB1REHLhn4+wNKJb+9b58wtdTmDIuFO1tyCAMKrOKyKLCyBmZrl5WVwdNkcjIhxPEwBqSm8ttSqfjLxN2JaT9rWRlw7Jjtz8l0OrDycv78TjhwCQA/d6rmCwE1Bdtfs9o4pk+fDoAfzj179myoTBKL6nQ6HD58GN26dbNqAQkh1pWVZf3+VQA4fvx9VFeXQC73Q8+e71nnoOBHLGdm8tt79wL9+lnt0PViJv2rthq4NHf9epRWVMBXpcKsZ56x+vENU25YVRX0RUVgjDllzdtZNavGmpaWhrS0NDDGcPr0aeF5Wloazp49i65du2LVqlVNPt6+ffvw6KOPIiIiAhzHYcuWLWbvT5w4kb9BTB59+/ZtTpEJIbUYaquAdftXz579BqdPf4qzZ7+x3kFh/0QR9si6lLhrFz7/+Wck7tplk+MDMM5V0umMTdvELppVY91bMz5/0qRJ+O9//wtfX98Wnby8vBxdu3bFpEmT8MQTT9S7z/Dhw5FoMoJO7oxD3wlxILYKrLbi4wN4e/NNwb//zqfxNelCtDrm5HNYDTiFAoZOO/2tW5C08O81aTqLhrslWmmo+IgRIzBixIg77qNQKBqc0kMIaT7T/lVHnL9am6Gf9fx5oKoKOHQIGDTIduczTQ7hcHkem8F08QD9rVtAbKx4hXEzTQ6sY8aMwapVq+Dr64sxY8bccd+ffvqpxQUzSElJQWhoKPz9/TFo0CDMnTsXoXf4a6BWq6FWq4XnpabD5glxc9nZwOXL/HZoqPX6V23NEFgBvp/VpoHVtCnYiVvIaGSweJrcx+rn5yd0fvv5+d3xYS0jRozA2rVrsWfPHixatAhHjx7FAw88YBY4a5s/f75ZWaKjo61WHkKcnbM1AxvYs5/VlZqCDSiw2leTa6ymzb/WagpuzLhx44TtTp06oVevXoiJicG2bdsarDW/9dZbwuhlgK+xUnAlhOesgdXbG/D1BUpL+abg8nLAy8s253KVpmDTEc20yo19WTSPtbKyEhUVFcLzK1euYMmSJdhlyxFuAMLDwxETE4MLFy40uI9CoYCvr6/ZgxDC27eP/1ciAVq1ErcszWWotWo0wIEDtjuPUGOVSMA5S1t5PTiJRAiu+lu3Gsw/QKzPosA6atQorFmzBgBQXFyM3r17Y9GiRRg1ahSWLVtm1QKaKiwsRE5ODsKd6as2IQ4iLw8wfCcNCXG+TH32WEaOMWbsY3Xm2moNoTlYrQYzqQwR27IosJ44cQL33nsvAGDTpk0ICwvDlStXsGbNGnz22WdNPk5ZWRnS09ORnp4OAMjKykJ6ejqys7NRVlaGGTNm4I8//sDly5eRkpKCRx99FMHBwXj88cctKTYhbs1Zm4ENTMtss35WtVrIm+jMA5cMOJNMePrCQhFL4l4s+s5aUVEBHx8fAMCuXbswZswYSCQS9O3bF1euXGnycY4dO4bBgwcLzw19o88//zyWLVuG06dPY82aNSguLkZ4eDgGDx6MjRs3CucmhDSdaWC1RX7g8PBBqKq6CU/PYOsfHIBKBQQEAEVFwPHj/FJy/v7WPYc9kkMAwL2dOqGwtBRBNu6qqrPKTevWNj0f4VkUWOPj47FlyxY8/vjj2LlzJ6ZNmwYAKCgoaFaf5v3333/Hdv+dO3daUjxCSD0MgZXjbNO/+sADa61/0FoiI/nAqtfz/cWPPWbd49tr4FLi//2fzY5tipaPE4dFTcGzZ8/GjBkzEBsbiz59+qBfTfLOXbt2oXv37lYtICGk5QoKgDNn+O2QEOftPjStae/ebf3jMxeZw2pgFlipKdhuLKqxjh07FgMHDkReXh66du0qvP7ggw9S/ychDsjZ+1cNwsP5GjdjtulntVdTsN2YBFYdBVa7sXhcYFhYWJ1Ug717925xgQgh1ucqgVWhAIKDgRs3gD//BK5ft26ztmmN1VYr29gTx3H8RVOroS8spFVu7MSiwFpeXo6PPvoIu3fvRkFBAfR6vdn7ly5dskrhCCHWYVjYnOP4peJs4ZdfHkBl5XUola0wcqTt0iNFRvKBFeBrrdZcdU1vp6xLI2bNQkFxMUL9/fHr3Lk2Ow/AjwxmajWg1YKVlICz9ogvUodFgXXy5MlITU3Fc889h/DwcPoGRIgDKygA/vqL3w4Otl1FrKTkPMrLc1FdXWKbE9SIiABqZuhh924rB1ZDjZXjbDrR98K1a7hWWIgSO8wtNV3lRldYCAkFVpuz6M759ddfsW3bNgwYMMDa5SGEWJmhtgrYZpqNvRkWZ9fprD+AiZkkh3CVCoPZXNabN4G77hKxNO7BolHBAQEBCAwMtHZZCCE2YJqlyBUCq0xm7Fe9fBmwVs8Tq64Gq6wE4Bojgg3qBFZicxYF1g8//BCzZ882yxdMCHFMhsBqy/5Ve7PFtBuXGxFcwzSw6iiw2oVFTcGLFi1CZmYmWrVqhdjYWHjUuglPnDhhlcIRQlomNxc4d47fDg113vmrtUVFAceO8du//Qb8/e8tP6a+xKRv2JVqrDIZX83XaqEvKBC7OG7BosA6evRoKxeDEGILpnM9XaEZ2CA4mP+SoNHwP6Nez6/Y0xLMJLC6UlMwAHBKJdjt22AVFdCXl0NiqzX3CAALA+t7771n7XIQQmzAtJnUdHUYZyeR8F8UrlwBbt4ETp0CunVr2TH1LpZ1yRTn6Sksh6e/cYMCq41Z/B2vuLgY3377Ld566y3cqslBeeLECeTm5lqtcIQQy5lmJ5JKnW/91caYflH47beWH8+sKdhV2sxrmPWzGiYBE5uxKLCeOnUK7dq1w4IFC/DJJ5+guLgYAJCUlIS33nrLmuUjhFjo4kUgJ4ffNkxRcSVRUcZtawRWV8sTbIpTKoVt/fXrIpbEPVjUFDx9+nRMnDgRCxcuNFvCbcSIERg/frzVCkcIsdyuXcZtezQD9+gxGxpNGTw8vG1/MgB+foCXF1Bezq90U1UFmFTMmk1fU0GARGLzbyFvjRuH8qoqeLWkwM1gVmOlAUw2Z1FgPXr0KJYvX17n9cjISOTn57e4UISQlktONm6b1u5s5e67/2H7k5jgOP4Lw/nzQGUl8McfgMnyzs3CGBMCK6dQ2Dw5xIvDh9v0+LVxMpkw2ktXUEA5g23MoqZgT09PlJomq65x7tw5hISEtLhQhJCW0WqN81c9PYGgIHHLYyumNXHTLxLNxW7f5ocWAy411caU0BysVpsvNkCszqLAOmrUKHzwwQfQaDQA+BUUsrOz8eabb+KJJ56wagEJIc135Ahg+NsZGcnX7lyRtQKr0AwM1+tfNTDtZ9VRy6JNWRRYP/nkE9y4cQOhoaGorKzEoEGDEB8fDx8fH8y18UoNhJDG7dhh3LbXNJuKijyUlV1FRUWefU4IQKUCDNlVjx8HLF1y1N6BNe/WLVy9eRN5NTMq7MEssNIAJpuyqI/V19cXBw4cwN69e3H8+HHo9Xr06NEDQ4YMsXb5CCEW2LnTuB0dbZ9zJiXdg/LyXHh5ReLZZ6/a56Tg+49v3eKnF+3eDTz1VPOPYRZYTRYHt5V7/+//cK2wEBFBQbiYmGjz8wGARKWCrmabaqy21ezAqtfrsWrVKvz000+4fPkyOI5DXFwcwsLCqEOcEAdw8yZw9Ci/HRjIj5x1ZVFRfIIIgB8JbVFgLSoyPnHRpmAoFPyIZ70eegqsNtWspmDGGB577DFMnjwZubm56Ny5Mzp27IgrV65g4sSJePzxx21VTkJIEyUn87U3wD6jgcVmOkd31y7jz94cpoHVHjVWMXAcJ0y70RcV8YufE5toVo111apV2LdvH3bv3o3Btca179mzB6NHj8aaNWvwt7/9zaqFJIQ03fbtxm17NQOLSSbjg2tuLp8Q49w5oH375h1Db+jrlMnAuVomDROcSgVWsyqZLj8fspgYkUvkmppVY12/fj3efvvtOkEVAB544AG8+eabWLt2rdUKRwhpHp0O+PVXftvDw3WWiWuMac3ctH+5KZhGI+TRddXaqgGNDLaPZgXWU6dOYfgdJjaPGDECJ0+ebHGhCCGWOXrUODI2MtL10hg2xLRmbppxqincoRnYgFOphG0KrLbTrMB669YttLpDJu9WrVqhyHQQACHErrZtM263bi1eOewtIICfegMAKSlAc7oP9SZTXlw+sJrWWPPsNy3K3TQrsOp0OshkDXfLSqVSaLXaFheKEGKZ//3PuO1OgZXjjM3BFRXAgQNN/6xpYIWrB1aJxDiA6cYNMJ2ukU8QSzRr8BJjDBMnToSigZtPTaPMCBHNlSuAoScmJMRYg3MXUVF83mCA72d98MGmfU5386aw7eo1VqBm0fOqKn7aTUEBpOHhYhfJ5TQrsD7//PON7kMjggkRxy+/GLfdcbCn6QCmHTuAhQub9jm9Sbomzk6rzYiJU6mAmi47XX4+BVYbaFZgTbRThhBCSPNt3WrcFiOwPvLIbuj1WkgkFiV0azFPT76mfuMGcPo0P/2mKekc9YYaq4eH3ababP/wQ2j1esgkFmWVbRGzAUx5eUD37nYvg6sT5zeAEGJVxcXAnj38tre3MX+uPfn7J9j/pLVER/OBFeCbg1944c776ysqhHmd9mwGbidi5g7KGWx79v+6ZGLfvn149NFHERERAY7jsGXLFrP3GWOYM2cOIiIioFQqcf/99+Ovv/4Sp7CEOLDt2/ml4gAgNtZ1V7NpjOm0m6bMZ9Wb9q+6QTMwYLI2K/imYGZJqipyR6IG1vLycnTt2hVffPFFve8vXLgQixcvxhdffIGjR48iLCwMDz30EG7XTOYmhPCSkozbsbGiFUN0ISHGgb27dhm/bDREb6jewn0CK2BSa62uBjNZgIBYh6hNwSNGjMCIESPqfY8xhiVLlmDWrFkYM2YMAGD16tVo1aoV1q1bh5deesmeRSXEYVVWGrMtKRTiZVu6eHEdtNoKyGQqxMePF6UMEgnfr3rpEt88fuQI0L9/w/vrCgqEbdMmUlvbmJqKCrUaKoUC4wYNstt5DTiVSljsXJefD0lAgN3L4Mocto81KysL+fn5GDp0qPCaQqHAoEGDcPDgwQYDq1qtNpv2U2pY7ZkQF7VzJ1Bezm/HxvLBRQyHD88Ulo0TK7ACfHPwpUv89q+/NhJYRaqxzlq1Slg2TozAKlEqoa/Z1uXnw+Puu+1eBlcmalPwneTXpNuqnempVatWwnv1mT9/Pvz8/IRHtDtkISdubdMm43ZcnHjlcBSmv/KGmnxD9IYaq0wGrqbf0R2YDWAyqbUT63DYwGpQe33XxtZ8feutt1BSUiI8cnJybF1EQkSjVhuzLcnlTZte4upUKiAoiN8+fhxoaOCrvrwcrKaq7079qwCMa7MC0NPIYKtz2MAaVtNRVLt2WlBQcMd8xQqFAr6+vmYPQlzVrl2AobcjJsZ9ku43pimjg00DCudmaarqrM1aXS1yiVyLwwbWuLg4hIWFITk5WXituroaqamp6H+nThNC3MgPPxi377pLvHI4GtM8yabr05oyXd3FngOXHAU1B9uOqIOXysrKcPHiReF5VlYW0tPTERgYiNatW2Pq1KmYN28e2rZti7Zt22LevHlQqVQYP168gRGEOIqqKuDnn/ltagY2FxrKX5PqauO0m9rrh1BgNf7M+uvXzXNCkhYRNbAeO3bMbNH06dOnA+BzEq9atQozZ85EZWUlXn31VRQVFaFPnz7YtWsXfHx8xCoyIQ5jxw7AMKU7NpaagU1JJHycuHSJT4t7+DAwYID5PkJgNWkWdSeUgcl2RA2s999//x2zfnAchzlz5mDOnDn2KxQhTmLDBuM2NQPX1bq1cdrN9u3mgZVVVwtZlzhPT3BizVESETUF24773U2EuIDycuNoYIWCmoHrY9qyaboAPFBTW635Uu9uA5cMTFMb6gsKKLWhFVFgJcQJbd3KL+gNAG3aiJcUwpRSGQYvr0golSKlfqpFpeJTHAL8OrW5ucb3dNeuCdtiBNZWAQGICApCK5EzHhmawFllJVhZmahlcSUOm3mJENKwdeuM247SDDxmzDGxi1CH6Wo327YB//gHv63LyxP2ESOw/r54sd3PWR9OqQSr6ajXFRRAQuNXrMIBvucSQpqjsJAfuAQAXl4ArVPdMNNpN6bNwTpD9ZXj3HJEsIHZyGDqZ7UaCqyEOJlNm4yrttx1l/suEdcUISGAIXb89hs/RYlVVkJfWAiADyzuOHDJwHQ0NA1gsh73vaMIcVLff2/cjo8XrxzOgOOMWZgqKoCUFEBr0tnKeXmJUzAHYRpYqcZqPdTHSogTuXwZOHCA3w4IMObEdQT79r0EtfoWFIpA3HffcrGLI2jdGjh/nt/+5Rfg/rFXhffECqz//PJLFN2+jQAfH3zx2muilAEAOKmUH1auVkN340ajudhJ01BgJcSJmA5aio93rGbgnJxtwrJxjiQqih81rdfzU5Q+6mNcmEMiUmDdceyYsGyc2DhPTzC1GtBooC8qgjQwUOwiOT1qCibESTAGfPed8Tk1AzeNXG4c4JV7VQ9Ndk2N1cODf9PN0QAm66PASoiTOH4cOHuW3w4PB2hmRNPFxPD/dgy9DomWX8lF4uVFzZ6gAUy2QIGVECdhWltt21a8cjgjQ2DtF5MtvMZ5e4tUGscioRqr1VFgJcQJaDTA+vX8tlQKxMWJWx5n4+MDBAYCA2MvC69RYK3h6Sl01lMyfuugwEqIE9ixw5hBKCaGH8hJmic2hmFAzBUAgA5St04MYcps0fPCQjDDJGliMQqshDiB1auN2+3aiVcOZzaw/XUEqioBAIVqb+pfNSF8yWBMWPWHWI4CKyEOrrDQuJKNUknrUVuqd1imsH25wAfVGhEL42BobVbrosBKiINbvx6o5geyIj7eMVaycUYJnsbAmlPsi5ycO+zsZiiwWhcliCDEwa1aZdxOSBCtGI26665noFYXQaEQdym0+nhw1YiT8yOCb6vlKFUrkJUF3NVGnPI8dd99KCorQ4CDDKAym8tKgbXFKLAS4sBOneLnrwJAcDA/stVR9e37sdhFaFBbxSXIOB0A4NptXwAcsrMBrQ6QSe1fnnmTJtn/pHcik/EPrRa6/HxKbdhC1KhEiANbscK47ci1VUfXQXFO2L6p9gPAT2EyXfzcnXEmy+exigphjVZiGQqshDgotdq4ko1USikMLSWBHh08+Sz8OiaBWmZMWZWVJVapHI/pgu+6/HwRS+L8KLAS4qB++gm4dYvfjoujuauWaiO/DG9pBQCgWOcLpUoiDAC7fBnQ6cUrmyMxG8CUlydiSZwf9bES4qCWm6y81r69eOVoqo0b26Oi4hpUqgiMG3dW7OIIuin/FLYLtQHgJHwmppISvlUgNxdoHW3nMr3yCvJu3UJ4YCDSly2z78kbIFGpoKvZpsDaMlRjJcQBnT0LpKby2/7+xtVZHJlWWwaN5ja02jKxiyLw4DToovwLAN8MXKzj+1dNFzC4dMn+5SqrqsLtykqUVVXZ/+QNUSiEuVy6a9dELoxzo8BKiAP66ivjdvv2jrXuqjPp7JkBTwk/CbhQGwB9zZ88by9Qc3AtHMcJ/azs9m3oaQCTxSiwEuJgysuNc1elUkph2BJ9vY4L2wVa46LihuZggG8OvnrV3iVzTGYDmKjWajEKrIQ4mO+/5/v/AH4ksMlymaQZIj3yECvn0ytV6D1Rpvcye9/X17h98aI9S+a4JF7Ga6SjuUgWo8BKiANhDPjvf43PO3YUryzObqDXIWE7XxMCwLw93cuLbxEA+OZgDS3qAs4ksGqpGm8xCqyEOJCdO4EzZ/jtsDA+2xJpPj9JqTAaWMOkuGnSDGzAccbmYK2WD67ujpPLAQ8PAHyNlemp89kSFFgJcSCLFhm3O3cWrxzObqD3IUg5Pihc14QIg5Zq8/Mzbl+4YI+SOT6h1lpdDX1BgbiFcVIUWAlxEMeOAb/9xm/7+vILmpPmU3KV6KviBy3pGVfTDFw/lUqooOHqVaCi0h4ldGwSk4UBtNnZIpbEeTl0YJ0zZw4/BNzkERYWJnaxCLGJjz4ybnfpQsvDWaqv1zEoaqbYFGiDoIXHHfc3DGJijAYxAQBnElh1V66IWBLn5fCZlzp27IjfDF/jAUilIixFQYiN/fknsHkzv61UOucUm4EDv4JOVwmpVNn4zjYigxYDvQ4D4ANlnqZVo5/x9+cXkweAc+f4JnhbTxv+7NVXUaVWw9MB81RySiX/rU6vh/bKFVrpxgIOH1hlMhnVUonL++AD43bXrvwKXs4mJmak2EVAN+Vp+EjLAQC3dP5Qs8YDl1zOf5mprORzM9+8CYTYeNDYw/fcY9sTtADHceC8vcFKS8HKy6G/eRPSkIab00ldDt/YdOHCBURERCAuLg5PP/00LjWSf0ytVqO0tNTsQYgjS0sDfvyR31YqgQ4dxC2P82IY6H1YeNaU2qqB6SCmc+ca3s9dSExyPmrFyPno5Bw6sPbp0wdr1qzBzp078c033yA/Px/9+/dHoaHdph7z58+Hn5+f8IiOtnN2bUKa6e23jdvdujlnbdURtJFfQYTHdQDAbZ2qTkKIO/HzM/ZpX7jAT79xZ5xpYKW19ZqNY4wxsQvRVOXl5bjrrrswc+ZMTJ8+vd591Go11Gq18Ly0tBTR0dEoKSmBr2mqFUIcQHIyMHQov+3jAzz1lDFpgbO5ceM49PpqSCRyhIT0tPv5JwT8iC7KDADAhapYFOoCm/X5a9eMGa/uvx9IsGE/94mLF6HRauEhk6GHAy60yxiD5tQpQKcDFAr4/utf4Jz1xhSBU3039vLyQufOnXHhDhPOFAoFFA44IICQ2rRaYNo04/NevZw3qALArl2jUF6eCy+vSDz7rH2z9vhKbqOjJ79UXbVehls6/2YfIyDAGFjPnLFtYH1q7lxcKyxERFAQLiYm2u5EFuI4DhJfX+iLigC1GrqrVyGj+V9N5tBNwbWp1WqcOXMG4c6whhYhjVi6FPiLX9EMISF8XmBimXtUJ4SEEAXaYDAL/rQplca8zNevAzduWrOEzoczaeHT0jykZnHowDpjxgykpqYiKysLhw8fxtixY1FaWornn39e7KIR0iJ5ecA77xif9+9PS8NZSgI9+nidAMBPsSnQWj6kNyDAuG340uOuJCaBVUOBtVkcOrBevXoVzzzzDBISEjBmzBjI5XIcOnQIMdQkQZzclCmAYbnL9u2BVk0fwEpqaa+4AH8pP/q/SOeHaia3+Fi+vsbm+IsXgUoHWofc3jgPD2EZOX1+PvQ0w6LJHLqPdcOGDWIXgRCr27zZmAzC0xPo3Vvc8ji7vl7HhO2W1FYBfmSwIWGETgdkZAA9e7SwgE5M4ucHXUUFAEBz/jwUvXqJXCLn4NA1VkJcTUEB8PLLxuf9+9N6qy0RIC1COwXfTKnWy1Gsa/nI/4AAY7P8n3+699QbzmSCr/b8eRFL4lwosBJiJ4wBf/87n9kHAGJjgbvuErVITq+f1zFIaoLgdW0wrJGM0MPDuJxcVRVw1o0TRnBKpbBKgfbSJbDqapFL5BwosBJiJ8uXA1u38tuensC999KApZbw4KrRW8UPWtIzDgWaumuuWirI5FAnTwI6N12WlOM4SAy1Vp0O2sxMcQvkJCiwEmIHp06Zz1kdNIif3kEs11N5EioJP7qoUBvQ6Co2zeHpCRgWeSkrA86etdqhnY7EpDlY484XohkosBJiY7dv8xmVqmpGmHbsSGutthQHPe7zPiQ8z9OGWv0cpnnn09Lct6+V8/ER8j1qzp8H0+lELpHjc+hRwYQ4O0O/qiGxe1AQ0KePuGWylSefPAOAwfaLrgFdPDMQLLsFACjR+aBCr7L6OTw9+b7W27eB8nLg1GmgR3frHDvtyy/tdKVajpNIIPHz47MwVVVBe/kyPGhwwB1RjZUQG/rsM2DjRn7bwwMYMsR1k+zL5T6Qy30hl/s0vnMLcGB4wGe/8Dy32naTgENCjP3g6elAeYV1juujUsFXpYKPyvpfCGxB4u8vbGupObhRFFgJsZH9+4EZM4zPBw82X56MWKaL518I9ygAANzWeaFUb7tArlDw81oBQKMBDh264+4ui/P1Fb5haM6ehROt3SIKCqyE2EBuLvDkk8Z+uW7d+Ok1pGUk0GGY717h+VVNOGzdoBoSYp6NKce+6ws4BE4qFXIHs7Iy6LKzRS6RY3PRRilCxFNVBYwZwydyB4DISH7lGld36tRiVFeXQi73RZcu9S/r2FJ9VcdN+la9UaKzbbMzwAfV0FA+vzMA7NsHPDkWkFueORGfbdmC0ooK+KpUeH30aKuU09Yk/v7Q1Sz/o8nIoNVu7oBqrIRYEWN8ZqUjR/jnPj7Agw8aF9F2ZadPL8aJE+/j9OnFNjm+J1eFh3xShOfZ1ZGw1/Aff3/Aq2bd9LIy4MDv/DAtS33288+Yt2EDPvv5Z2sUzy4k/v7G5uCMDDC9m07ubQI3+HUnxH6WLAFWr+a3pVJ+EXNKWWgdD/rsg5e0EgBwUxuAcr2XXc8fHm78gnThgnGkt7uo0xx85YrIJXJcFFgJsZJff607WCnIesmA3Fqg9BYGeB0GwGdZ4mur9uXhwQdXgwMHgIIbdi+GqCQm6+pVnz4tYkkcGwVWQqzg1Clg3DjA0DrWowfQpo24ZXIlI3x3Q1azkHmeJrRFS8O1hK+vcc1WnQ7YuRMoKxelKKKQ+PkZk0VkZIC5a9aMRlBgJaSFcnOBkSON66vGxQE9e4pbJlcS7XEVXZUZAIBqJkOuJkzU8rRqBRimn1ZUANu3A1VqUYtkN5xUapzTqlZD427t4U1EgZWQFigpAR5+GMjJ4Z+HhPBNwJRc31oYHvb9TXiWWx0OPaQilof/v42KMo4KLioCduwAqjWiFstuJIGBwrYmLU3EkjguCqyEWKiyEnjsMb4ZGOBHAA8b5rqZlcTQTpGJuxT8IJlKvaLFC5lbi1QKREcb/6+vX+eDq8YNWkY5Hx/hW4U2M5NPdUjMUGAlxAJqNfDEE/ycRoAf+TtihLGJkFgDw3CfPcKznOoIMAfKriuX88HVkDwiL48fwObqwZXjOEiDjV9w1EePilgax0SBlZBmUquBsWP5P6IAP1p0xAhj6jtiHZ08zyJKzmdlKNcpcUvnL26B6uHpCbRubR5ct293/WZhSVCQ0N9RfeIEmNpNOpmbiAIrIc1QUQGMHg388gv/XCoFhg83X2LMXQUF9UBoaF8EBfVo8bE46DHUx5i6MEcTAUddC6Z2cM3PB7ZtA9TVDX+m2113oXdCAro56SoxnIeHsa9VrUb1sWPiFsjBcMzFsymXlpbCz88PJSUl8K2Z3EyIJW7d4vtUf/+dfy6T8UE1IkLccrmiHsqTeDpgCwA+0f5fVe3gqIHVoKoKyM7mp+EAQHAwP7BN6aIJQlhVFTQZ/GhtTqWCz+uvg1MoRC6VY6AaKyFNcOkSMGCAMah6ePB/NCmoWp8UWrPUhTnVjltbNeXpyS9gbxjQdPMm8L//WW+pOUfDeXoKCSNYRQXUhl8OQoGVkMakpPCLkxuWoVQqgUcfBcLEnU7psvp7HUWQrBgAUKzzsemycNamUJgH16IiPrjeLhO3XLYiDQ8X+lrVBw9CV1gocokcAwVWQhrAGLB4Mb84+c2b/Gv+/sCoUXwzH7E+L0k5HvThh1ozBlFSF7aUXM4HVw8P/nlJCfDzz0BRsajFsgnO0xMSwwADnQ6VP/9MyflBy8YRUq/CQuDFF/k/iAZRUfxKNdSNVL8dOx5DVdUNeHqGYPjwrRYd42Hf36CSVAEAbmgDUaF3zvlLhuCanQ1UVwPl5fy9NHw4ENYKGPuf/+BmSQmC/fyw6Z13xC5ui0jDw6EvLgaqq6HLyYF6zx54DhkidrFERYGVkFp27gReeAG4ds34Wrdu/Jqq7rD8m6UKC0+gvDwXXl6W1TITFBdwjyodAKBlEuQ4YW3VlIcHH1xzcviBTWo1P5p80CAgPTMT1woLEeECqzRwUilksbHQnj8PAFD//jskwcGQd+smbsFERH8mCKlRUgL84x98rcIQVBUK/nnv3hRUbclXUopx/luE59nVUdDAQ7wCWYlMxgdXw1quOh2wZw9fi3UlEm9vSKOihOeVW7dC89dfIpZIXPSngrg9xoANG4D27YFvvjG+HhnJJ4Jo3Vq8srkDFVeBF4LWwVvKD58t0vqiQOv8NTkDiYTP0GSaQERTk0DClbojJSEhxv5WxlCxeTPUbjq/lQIrcWvp6cADDwDPPMNP7Af4JryBA/npNF72XUvb7YTIbuLl4FWI8LgOAKjSy5GpjoUzTK9pDo7j13INCzNfoKGyEti9B7jlAul2OY6DNCqKz8oEAIyhats2VP7vf2AaF09FVQv1sRK3dO4c8MEHwPr1fI3VoHVrPqh6e4tXNtfHECYrwD2qNPT1OgYPjs+oUK2X4WxVPLQu/GcpIICfrmUaXC9e5B/h4fwavtHR/LqvzvjVguM4SGvSUOkLCgDwKQ+1V65A+fDDkLnJIsVOcQcvXboUH3/8MfLy8tCxY0csWbIE9957r9jFIk6GMX5O6hdfAFu2mDfD+fgA/frx/WG05FvLRXnkIlBaDF/pbXhJKqCUVEIlqYSf5DZCZTfgJa00279C74lzVW2gZi6apsiEp6cx/aGpvDz+AfDBNyQECAzkm5AND4U467s3C8dxkEVFQadUQpedDTAGfWEhyr/7DtK4OCj69IEsPh5cfRfBRTh8YN24cSOmTp2KpUuXYsCAAVi+fDlGjBiBjIwMtKbOL9KIykrg8GE+Yf6PPwJZWebvKxRA9+5Ax471/7EjdyaBHq1kBYiR5+AnrhLlAPwkpXg95NsmfV7HOORrQpGrCRN9nVV7Mnx3k8n4hdOLi/lRwwaVlfxUnexs8895egJ+fnyN1vCvjw/fZaFSAVIH6tyTBgVBolJBe+UKWAXff67LykJFVhY4pRKy+HjIYmP55uPgYHAuNDrQ4QPr4sWL8eKLL2Ly5MkAgCVLlmDnzp1YtmwZ5s+fL3LpiJhOnwYOHeL/IJWXA6Wl/PzT/Hw+gJ45YxwkUp+2bYEOHfg+1ZIS+5XbWbT2zEOU53XIOB08JBooJWp4SSvh71GGYI8ihCtuwFNqvMDvcE3vR6vSyXFL44uC6gBomAwcqt0orAIA3//AgSHEtxIhvvxI4YoKoKoS0N5h6Tl1CXCjBLiRY73SSKSATMr/LtT3kEkBqQf/5VPC8f9yEv4LAscZW3n8AwDfWomypDEx0N+6Bf3168afvrISmtOnoTl92rgjx0ESEACJvz84Hx9wSiX/kMsBmYyv4UokgEQCWZs2kDjwAAiHDqzV1dU4fvw43nzzTbPXhw4dioMHD9b7GbVaDbXJV7+Smr+YpaWltisosbvly4GZM1t2jAsX+Aep6//u3Yc3Btw592u1xnx5NH1NZ7WeMZRWVTVyhip4oxTe8qstLKlzkqFa+DdBkca/qADgqNkbdTWPRmgLgVstOU9lpfkE8oZIpfAaNw6ymBiLTuPj4wPOln0+zIHl5uYyAOz33383e33u3LmsXbt29X7mvffeY+C/DtKDHvSgBz3oUedRUFBg09jl0DVWg9rfLBhjDX7beOuttzB9+nTheXFxMWJiYpCdnQ0/Pz+bltOVlJaWIjo6Gjk5ObTcXhPRNbMMXbfmo2tmGcN1k8ttOwrMoQNrcHAwpFIp8g0TDGsUFBSgVatW9X5GoVBAUU8yVz8/P7oBLeDr60vXrZnomlmGrlvz0TWzjE2bgeHgCSLkcjl69uyJ5ORks9eTk5PRv39/kUpFCCGENMyha6wAMH36dDz33HPo1asX+vXrh6+//hrZ2dl4+eWXxS4aIYQQUofDB9Zx48ahsLAQH3zwAfLy8tCpUyds374dMU0cDaZQKPDee+/V2zxMGkbXrfnomlmGrlvz0TWzjL2uG8eYaUI3QgghhLSEQ/exEkIIIc6GAishhBBiRRRYCSGEECuiwEoIIYRYkdMF1qVLlyIuLg6enp7o2bMn9u/f3+C+EydOBMdxdR4dO3YU9lm1alW9+1Q1muvUuTTnugHA2rVr0bVrV6hUKoSHh2PSpEkoLCw022fz5s3o0KEDFAoFOnTogKSkJFv+CHZn7WtG91r9vvzyS9x9991QKpVISEjAmjVr6uxD95q5xq6ZO9xr+/btw6OPPoqIiAhwHIctW7Y0+pnU1FT07NkTnp6eaNOmDb766qs6+1jlXrNpwkQr27BhA/Pw8GDffPMNy8jIYG+88Qbz8vJiV65cqXf/4uJilpeXJzxycnJYYGAge++994R9EhMTma+vr9l+eXl5dvqJ7KO5123//v1MIpGw//73v+zSpUts//79rGPHjmz06NHCPgcPHmRSqZTNmzePnTlzhs2bN4/JZDJ26NAhe/1YNmWLa0b3Wl1Lly5lPj4+bMOGDSwzM5OtX7+eeXt7s61btwr70L1mrinXzB3ute3bt7NZs2axzZs3MwAsKSnpjvtfunSJqVQq9sYbb7CMjAz2zTffMA8PD7Zp0yZhH2vda04VWHv37s1efvlls9fat2/P3nzzzSZ9PikpiXEcxy5fviy8lpiYyPz8/KxZTIfT3Ov28ccfszZt2pi99tlnn7GoqCjh+VNPPcWGDx9uts+wYcPY008/baVSi8sW14zutbr69evHZsyYYfbaG2+8wQYMGCA8p3vNXFOumTvca6aaElhnzpzJ2rdvb/baSy+9xPr27Ss8t9a95jRNwYYl5IYOHWr2+p2WkKttxYoVGDJkSJ3kEmVlZYiJiUFUVBRGjhyJtLQ0q5VbbJZct/79++Pq1avYvn07GGO4fv06Nm3ahEceeUTY548//qhzzGHDhjX5/8KR2eqaAXSv1aZWq+Hp6Wn2mlKpxJEjR6CpWUyX7jVzTblmgGvfa5Zo6D46duyY1e81pwmsN2/ehE6nq5N8v1WrVnWS9NcnLy8Pv/76q7BgukH79u2xatUqbN26FevXr4enpycGDBiACy6yUKcl161///5Yu3Ytxo0bB7lcjrCwMPj7++Pzzz8X9snPz7f4/8LR2eqa0b1W17Bhw/Dtt9/i+PHjYIzh2LFjWLlyJTQaDW7evAmA7rXamnLNXP1es0RD95FWq7X6veY0gdWgOUvImVq1ahX8/f0xevRos9f79u2LCRMmoGvXrrj33nvxww8/oF27dmZ/EF1Bc65bRkYGXn/9dcyePRvHjx/Hjh07kJWVVSc/s6X/F87C2teM7rW63n33XYwYMQJ9+/aFh4cHRo0ahYkTJwIApFKpRcd0Rta+Zu5yrzVXfde59uvWuNecJrBasoScAWMMK1euxHPPPdfoOnwSiQT33HOPy3yzs+S6zZ8/HwMGDMC//vUvdOnSBcOGDcPSpUuxcuVK5OXlAQDCwsIs+r9wBra6ZrXRvcY3Ya5cuRIVFRW4fPkysrOzERsbCx8fHwQHBwOge622plyz2lztXrNEQ/eRTCZDUFDQHfdp7r3mNIG1JUvIpaam4uLFi3jxxRcbPQ9jDOnp6QgPD29ReR2FJdetoqICEon5rWH4Jmz4htevX786x9y1a5dLLOdnq2tWG91rRh4eHoiKioJUKsWGDRswcuRI4XrSvVa/O12z2lztXrNEQ/dRr1694OHhccd9mn2vNWuok8gMw9JXrFjBMjIy2NSpU5mXl5cwyvfNN99kzz33XJ3PTZgwgfXp06feY86ZM4ft2LGDZWZmsrS0NDZp0iQmk8nY4cOHbfqz2FNzr1tiYiKTyWRs6dKlLDMzkx04cID16tWL9e7dW9jn999/Z1KplH300UfszJkz7KOPPnLJKRDWvGZ0r9W9bufOnWPfffcdO3/+PDt8+DAbN24cCwwMZFlZWcI+dK81/5q5w712+/ZtlpaWxtLS0hgAtnjxYpaWliZMU6p93QzTbaZNm8YyMjLYihUr6ky3sda95lSBlTHGvvzySxYTE8Pkcjnr0aMHS01NFd57/vnn2aBBg8z2Ly4uZkqlkn399df1Hm/q1KmsdevWTC6Xs5CQEDZ06FB28OBBW/4Iomjudfvss89Yhw4dmFKpZOHh4ezZZ59lV69eNdvnxx9/ZAkJCczDw4O1b9+ebd682R4/it1Y+5rRvVb3umVkZLBu3boxpVLJfH192ahRo9jZs2frHJPutUHC86ZcM3e41/bu3csA1Hk8//zzjLH6f0dTUlJY9+7dmVwuZ7GxsWzZsmV1jmuNe42WjSOEEEKsyGn6WAkhhBBnQIGVEEIIsSIKrIQQQogVUWAlhBBCrIgCKyGEEGJFFFgJIYQQK6LASgghhFgRBVZCCCHEiiiwEiKCgwcPQiqVYvjw4WIXhRBiZZR5iRARTJ48Gd7e3vj222+RkZGB1q1bi1IOjUYjJCAnhFgH1VgJsbPy8nL88MMPeOWVVzBy5EisWrXK7P2tW7eiV69e8PT0RHBwMMaMGSO8p1arMXPmTERHR0OhUKBt27ZYsWIFAOOaw6a2bNlitpbknDlz0K1bN6xcuRJt2rSBQqEAYww7duzAwIED4e/vj6CgIIwcORKZmZlmx7p69SqefvppBAYGwsvLC7169cLhw4dx+fJlSCQSHDt2zGz/zz//HDExMQ2u7kOIq6LASoidbdy4EQkJCUhISMCECROQmJgoBJ9t27ZhzJgxeOSRR5CWlobdu3ejV69ewmf/9re/YcOGDfjss89w5swZfPXVV/D29m7W+S9evIgffvgBmzdvRnp6OgA+2E+fPh1Hjx7F7t27IZFI8Pjjj0Ov1wMAysrKMGjQIFy7dg1bt27FyZMnMXPmTOj1esTGxmLIkCFITEw0O09iYiImTpzoUguSE9IkzU7bTwhpkf79+7MlS5YwxhjTaDQsODiYJScnM8YY69evH3v22Wfr/dy5c+cYAGHf2hITE5mfn5/Za0lJScz01/y9995jHh4erKCg4I5lLCgoYADY6dOnGWOMLV++nPn4+LDCwsJ699+4cSMLCAhgVVVVjDHG0tPTGcdxZkuZEeIuqMZKiB2dO3cOR44cwdNPPw0AkMlkGDduHFauXAkASE9Px4MPPljvZ9PT0yGVSjFo0KAWlSEmJgYhISFmr2VmZmL8+PFo06YNfH19ERcXBwDIzs4Wzt29e3cEBgbWe8zRo0dDJpMhKSkJALBy5UoMHjwYsbGxLSorIc5IJnYBCHEnK1asgFarRWRkpPAaYwweHh4oKiqCUqls8LN3eg8AJBJJnf5MjUZTZz8vL686rz366KOIjo7GN998g4iICOj1enTq1AnV1dVNOrdcLsdzzz2HxMREjBkzBuvWrcOSJUvu+BlCXBXVWAmxE61WizVr1mDRokVIT08XHidPnkRMTAzWrl2LLl26YPfu3fV+vnPnztDr9UhNTa33/ZCQENy+fRvl5eXCa4Y+1DspLCzEmTNn8M477+DBBx/E3XffjaKiIrN9unTpgvT0dNy6davB40yePBm//fYbli5dCo1GYzboihC3InZbNCHuIikpicnlclZcXFznvbfffpt169aN7d27l0kkEjZ79myWkZHBTp06xRYsWCDsN3HiRBYdHc2SkpLYpUuX2N69e9nGjRsZY4wVFhYyLy8v9vrrr7MLFy6wtWvXsoiIiDp9rF27djU7t06nY0FBQWzChAnswoULbPfu3eyee+5hAFhSUhJjjDG1Ws3atWvH7r33XnbgwAGWmZnJNm3axA4ePGh2rP79+zO5XM5efvllK101QpwP1VgJsZMVK1ZgyJAh8PPzq/PeE088gfT0dPj6+uLHH3/E1q1b0a1bNzzwwAM4fPiwsN+yZcswduxYvPrqq2jfvj3+/ve/CzXUwMBAfP/999i+fTs6d+6M9evXY86cOY2WSyKRYMOGDTh+/Dg6deqEadOm4eOPPzbbRy6XY9euXQgNDcXDDz+Mzp0746OPPoJUKjXb78UXX0R1dTVeeOEFC64QIa6BEkQQQqxm7ty52LBhA06fPi12UQgRDdVYCSEtVlZWhqNHj+Lzzz/H66+/LnZxCBEVBVZCSIv985//xMCBAzFo0CBqBiZuj5qCCSGEECuiGishhBBiRRRYCSGEECuiwEoIIYRYEQVWQgghxIoosBJCCCFWRIGVEEIIsSIKrIQQQogVUWAlhBBCrIgCKyGEEGJF/w/K/5JZWLcgAQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 500x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---Prompt based mean and std---\n",
      "0.8909533333333334\n",
      "0.018290921852717596\n",
      "\n",
      "---KG-RAG based mean and std---\n",
      "0.9394266666666666\n",
      "0.013815617571751504\n"
     ]
    }
   ],
   "source": [
    "llama_fig = plot_figure(llama_prompt_correct_frac_list, llama_rag_correct_frac_list)\n",
    "\n",
    "fig_path = '../data/results/figures'\n",
    "os.makedirs(fig_path, exist_ok=True)\n",
    "llama_fig.savefig(os.path.join(fig_path, 'llama_true_false.svg'), format='svg', bbox_inches='tight')      \n",
    "\n",
    "print('---Prompt based mean and std---')\n",
    "print(np.mean(llama_prompt_correct_frac_list))\n",
    "print(np.std(llama_prompt_correct_frac_list))\n",
    "print('')\n",
    "print('---KG-RAG based mean and std---')\n",
    "print(np.mean(llama_rag_correct_frac_list))\n",
    "print(np.std(llama_rag_correct_frac_list))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "49f9f1ae",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/p1/h56gxdhs5vgb0ztp7h4z606h0000gn/T/ipykernel_52094/309868377.py:80: FutureWarning: \n",
      "\n",
      "`shade` is now deprecated in favor of `fill`; setting `fill=True`.\n",
      "This will become an error in seaborn v0.14.0; please update your code.\n",
      "\n",
      "  sns.kdeplot(prompt_correct_frac_list, color=\"blue\", shade=True, label=\"Prompt based\", ax=ax, lw=2, linestyle=\"-\", alpha=0.6)\n",
      "/var/folders/p1/h56gxdhs5vgb0ztp7h4z606h0000gn/T/ipykernel_52094/309868377.py:81: FutureWarning: \n",
      "\n",
      "`shade` is now deprecated in favor of `fill`; setting `fill=True`.\n",
      "This will become an error in seaborn v0.14.0; please update your code.\n",
      "\n",
      "  sns.kdeplot(rag_correct_frac_list, color=\"lightcoral\", shade=True, label=\"KG-RAG based\", ax=ax, lw=2, linestyle=\"-\", alpha=0.6)\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAdYAAAEmCAYAAADfiLFDAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAA9hAAAPYQGoP6dpAABZ+klEQVR4nO3deVhUZfsH8O+ZAYYdBGVHRBFMRVxzLbXcqMytN8vllcreVkv9mWWWYqWmptmmmQlquZWGr69bmila5i5qQai4sAihiCDbMMvz++MwZ2bYGWbmzHJ/rmsuZz1zcxi559nuh2OMMRBCCCHEKCRiB0AIIYTYEkqshBBCiBFRYiWEEEKMiBIrIYQQYkSUWAkhhBAjosRKCCGEGBElVkIIIcSIKLESQgghRmTziZUxhuLiYlAdDEIIIebgIHYApnb//n14eXmhqKgInp6eYodDiFmsWLECxcXF8PT0xMyZM8UOh5gQ/a4tD2frJQ2Li4spsRK7ExISgpycHAQHByM7O1vscIgJ0e/a8th8VzAhhBBiTpRYCSGEECOixEoIIYQYESVWQgghxIhsflZwYzDGoFQqoVKpxA6F2ABHR0dIpVKxwyCEiMTuE2tlZSVyc3NRVlYmdijERnAch5CQELi7u4sdCiFEBHadWNVqNa5fvw6pVIqgoCA4OTmB4zixwyJWjDGG27dvIzs7G+3bt6eWKyF2yK4Ta2VlJdRqNUJDQ+Hq6ip2OMRGtGrVCjdu3IBCoaDESsyKyeXgZDKxw7B7dp1YNSQSmsNFjMcSej0ef/xx3L17Fz4+PmKHQkzs8ccfx92CAnjcvYvijz+GQ4cOcH3qKXD0pU40lFgJsUFr1qwROwRiJmvWrIH89GlU7N0LAFD+/TcqT5+GrE8fkSOzX9RUI4QQK6e4cEH/9l9/iRQJAajFWquePYG8PPO+Z0AAcOaMed/T0hw5cgSDBw9GYWEhvL29xQ5HcOPGDYSHh+P8+fPo2rWr2OEQooeVl0N165befarsbKjLyiChuSOioMRai7w8ICdH7CjqFhcXhw0bNgAAHBwcEBoairFjx2LBggVwc3MTObqaKDERYjrKmzeBWvZSUeXmQtKunQgREUqs9eA4wNRf+MrKav0/0aARI0YgMTERCoUCx44dw9SpU1FaWorVq1fXeK5CoYCjo6MRoiXWomfPnsjLy0NAQADO2HtXiI3rM2oU8nJz4efujuTZs8GKigDwidWREqsoaIy1Hq6uwMSJpr0YmrhlMhkCAgIQGhqKCRMmYOLEidi5cycAID4+Hl27dkVCQgLatm0LmUwGxhgyMzMxatQouLu7w9PTE08//TT++ecf4Zi6r2vdujXc3d3xyiuvQKVSYenSpQgICICfnx8WLlyoFwvHcVi9ejViY2Ph4uKC8PBw/Pjjj8Lj4eHhAIBu3bqB4zgMGjSo3p/t999/R0xMDJydndG7d29cunRJeKygoADPPvssQkJC4OrqiujoaGzZskXv9du3b0d0dDRcXFzg6+uLIUOGoLS0VHg8MTERDzzwAJydndGhQwesWrVK7/WnTp1Ct27d4OzsjJ49e+L8+fMN/0IsTF5eHnJycpBn7jENYnZ5t2/j1v37yC8pgbRlS+F+VW6uiFHZN0qsNsLFxQUKhUK4ffXqVfzwww/YsWMHUlJSAACjR4/G3bt3kZycjIMHDyIjIwPjx4/XO05GRgb27duH/fv3Y8uWLUhISMDjjz+O7OxsJCcnY8mSJXjvvfdw4sQJvde9//77GDduHC5cuIBJkybh2WefRVpaGgA+UQHAL7/8gtzcXPz000/1/ixvvfUWPvnkE5w+fRp+fn548sknhZ+toqICPXr0wO7du/Hnn3/iP//5DyZPnoyTJ08CAHJzc/Hss8/i+eefR1paGo4cOYKxY8dCs+3w2rVrMXfuXCxcuBBpaWlYtGgR3n//faFrvbS0FE888QSioqJw9uxZxMfHY9asWYb8SggxD7Wa/5fjwHl68l1tANS3b4sYlH2jrmAbcOrUKWzevBmPPvqocF9lZSW+++47tGrVCgBw8OBBXLx4EdevX0doaCgA4LvvvkOnTp1w+vRp9OrVCwBfjSohIQEeHh7o2LEjBg8ejPT0dOzduxcSiQRRUVFYsmQJjhw5gj460/n/9a9/YerUqQCADz/8EAcPHsQXX3yBVatWCTH4+voiICCgwZ9n/vz5GDp0KABgw4YNCAkJQVJSEp5++mkEBwfrJbpp06Zh//79+PHHH9G7d2/k5uZCqVRi7NixCAsLAwBER0cLz//www+xfPlyjB07FgDfmk5NTcWaNWswZcoUbNq0CSqVCgkJCXB1dUWnTp2QnZ2NV155pYm/FUJMT11erp9YOQ6cTAZWUQH13btgajU4WqdvdpRYrdTu3bvh7u4OpVIJhUKBUaNG4YsvvhAeDwsLExIaAKSlpSE0NFRIqgDQsWNHeHt7Iy0tTUisbdq0gYeHh/Acf39/SKVSvSIa/v7+yM/P14unb9++NW5rWspNpXssHx8fREVFCa1flUqFjz/+GNu2bUNOTg7kcjnkcrkwaSsmJgaPPvoooqOjMXz4cAwbNgxPPfUUWrRogdu3byMrKwsvvPACXnzxReE9lEolvLy8hPMUExOjV4mr+s9GiKXQa5VqCpPIZEBFBaBSgRUXg7OgGfb2ghKrlRo8eDBWr14NR0dHBAUF1ZicVH12MGOs1opA1e+vfhyO42q9T635llwPY1Yg0hxr+fLl+PTTT7Fy5UpER0fDzc0N06dPR2VlJQBAKpXi4MGDOH78OA4cOIAvvvgCc+fOxcmTJ4VkuXbtWvTu3Vvv+JrSg8yQmWSEiKS2xMo5O2snMBUUQEKJ1eyoj8BKubm5ISIiAmFhYY2a8duxY0dkZmYiKytLuC81NRVFRUV44IEHmh1P9THXEydOoEOHDgAAJycnAGj0tny6xyosLMTly5eFYx07dgyjRo3CpEmTEBMTg7Zt2+LKlSt6r+c4Dv3798eCBQtw/vx5ODk5ISkpCf7+/ggODsa1a9cQERGhd9FMsOrYsSMuXLiA8vLyOn82QiyF6s6dGvfp1gpWFxSYMxxShVqs9SgrAzZtMv17mMOQIUPQpUsXTJw4EStXroRSqcSrr76KgQMHomfPns0+/o8//oiePXtiwIAB2LRpE06dOoV169YBAPz8/ODi4oL9+/cjJCQEzs7OQtdrbT744AP4+vrC398fc+fORcuWLTF69GgAQEREBHbs2IHjx4+jRYsWWLFiBfLy8oQvBydPnsShQ4cwbNgw+Pn54eTJk7h9+7bweHx8PN544w14enoiNjYWcrkcZ86cQWFhIWbOnIkJEyZg7ty5eOGFF/Dee+/hxo0b+OSTT5p9fggxBbVuYtW0WHUT6717Zo6IANRirRdjQGmpaS/m6nnkOA47d+5EixYt8PDDD2PIkCFo27Yttm3bZpTjL1iwAFu3bkWXLl2wYcMGbNq0CR07dgTAF7H4/PPPsWbNGgQFBWHUqFH1Huvjjz/Gm2++iR49eiA3Nxe7du0SWr3vv/8+unfvjuHDh2PQoEEICAgQki4AeHp64ujRo3jssccQGRmJ9957D8uXL0dsbCwAYOrUqfj222+xfv16REdHY+DAgVi/fr3QYnV3d8f//vc/pKamolu3bpg7dy6WLFlilHNEiLGpakusVf9XAEqsYuGYjQ8qFRcXw8vLC0VFRfD09NR7rKKiAtevX0d4eDicnZ2F+6mkYdNwHIekpCS9BGfP6vpcmVNISAhycnIQHByM7OxsUWIgpsUUChQvWoSOy5fj1v37CPL1xdXERDDGoKhaey0JCIDHSy+JHKn9oa7gWlhrgiNEY+nSpSgrK6N9hm2YZvx0wdChqHBygntwMICqiX5OTkBlJbVYRSJqV/Dq1avRpUsXeHp6wtPTE3379sW+ffuExxljiI+PR1BQEFxcXDBo0CD8Rbs2ENKgCRMmYOrUqZgwYYLYoRATUVXNCP5Xly6Ie+QRjB84UHhMGGetqACrqBAjPLsmamINCQnBxx9/jDNnzuDMmTN45JFHMGrUKCF5Ll26FCtWrMCXX36J06dPIyAgAEOHDsX9+/fFDJtUwxijbmBCzEx3qQ1XbciBxlnFJWpiHTlypDDJJDIyEgsXLoS7uztOnDgBxhhWrlyJuXPnYuzYsejcuTM2bNiAsrIybN68WcywCSFEdCqdIi2ci4veY5RYxWUxs4JVKhW2bt2K0tJS9O3bF9evX0deXh6GDRsmPEcmk2HgwIE4fvx4nceRy+UoLi7WuxBib9LT0/HXX38hPT1d7FCIiWharFfu3kVqXh4u605So8QqKtEnL126dAl9+/ZFRUUF3N3dkZSUhI4dOwrJ09/fX+/5/v7+uHnzZp3HW7x4MRYsWGDSmAmxdI8++ijNCrZhrLIS6rt3AQCjNmzAraIiYVYwQC1WsYneYo2KikJKSgpOnDiBV155BVOmTEFqaqrwePWyeHWV5tOYM2cOioqKhItupSFCCLEFKt31gLX8PdQrElFV3pCYj+gtVicnJ0RERADgN2c+ffo0PvvsM7z99tsA+H0lAwMDhefn5+fXaMXqkslkkOl8qAghxNaobt3S3qitoaFT5pRarOYnemKtjjEGuVyO8PBwBAQE4ODBg+jWrRsAfis0zZ6gplTyzTdQl5SY9D2qk7i7w/0//zHre1q69evXY/r06bhnYX8Yjhw5gsGDB6OwsBDeVOCciECVk6O9UVuLVXcta2Fhgz19xLhE7Qp+9913cezYMdy4cQOXLl3C3LlzceTIEUycOBEcx2H69OlYtGgRkpKS8OeffyIuLg6urq4mX5unLikBu3/frJemJPK4uLgay1u2b98OZ2dnLF26VLivuLgY77//Pjp16gQXFxf4+vqiV69eWLp0KQoLC+t9jzZt2vB7O3IcXFxc0KFDByxbtqzW3V+OHz8OqVSKESNG1HqsyspKLFu2DN27d4ebmxu8vLwQExOD9957D7d0v3kTQhrEGIPy2jX+hkRSe4sVOt3BcjmtZTUzUVus//zzDyZPnozc3Fx4eXmhS5cu2L9/v7DJ9ezZs1FeXo5XX30VhYWF6N27Nw4cOKC3X6jJNWLnmGZRKJp9iG+//RavvfYavvrqK2Gz8bt372LAgAEoLi7Ghx9+iB49esDJyQlXr17F5s2bsXnzZrz22mv1HveDDz7Aiy++iIqKCvzyyy945ZVX4OnpiZeqlUhLSEjAtGnT8O233yIzMxOtW7cWHpPL5Rg2bBguXryIBQsWoH///vDy8kJGRgZ27tyJL774AosXL272OSDEXqhyc8Gqdu/g6vlbyDk5QfM1mBUWAtWW5BDTETWxanY/qQvHcYiPj0d8fLx5AqrO0RFO0dEmfYvKS5ealVyXLl2KefPmYfPmzRg3bpxw/7vvvovMzEykp6cjuKrUGQB06NABTzzxRKP2HfXw8EBAQAAAvnj96tWrceDAAb3EWlpaih9++AGnT59GXl4e1q9fj3nz5gmPf/rpp/jtt99w5swZoUsf4HepGT58eKPi2LlzJ2bPno3MzEw89NBDSEhIEDZsz8jIwMyZM3HixAmUlpbigQcewOLFizFkyBDh9atWrcKnn36KrKwseHl54aGHHsL27dsB8N/+ly1bhq+//hq5ubmIjIzE+++/j6eeekp4/d69ezF9+nRkZWWhT58+mDJlSoMxE2IqlTo1VyXV6p/rqr7LjTQoyKRxES3RZwUTw73zzjv48MMPsXv3br2kqlarsW3bNkyaNEkvqepqyngLYwxHjhxBWlpajb1ft23bhqioKERFRWHSpElIrCoCrrFlyxYMHTpUL6k2JY6ysjIsXLgQGzZswO+//47i4mI888wzwuMlJSV47LHH8Msvv+D8+fMYPnw4Ro4ciczMTADAmTNn8MYbb+CDDz5Aeno69u/fj4cfflh4/XvvvYfExESsXr0af/31F2bMmIFJkyYhOTkZAJCVlYWxY8fiscceQ0pKCqZOnYp33nmn0eeOEGNQFxWh7L//xf2vvhIK7EMigcTHp+4X6S65qVqaQ8yDEquV2rdvH5YsWYL//ve/eq0zALh9+zbu3buHqKgovft79OgBd3d3uLu749lnn23wPd5++224u7tDJpNh8ODBYIzhjTfe0HvOunXrMGnSJADAiBEjUFJSgkOHDgmPX758uUYcY8aMEeLo169fvTEoFAp8+eWX6Nu3L3r06IENGzbg+PHjOHXqFAAgJiYGL730EqKjo9G+fXt89NFHaNu2LXbt2gUAyMzMhJubG5544gmEhYWhW7duws9QWlqKFStWICEhAcOHD0fbtm0RFxeHSZMmYc2aNQD4etZt27bFp59+iqioKEycOBFxcXENnjtCjIVVVKB0wwYoUlL09l+VBgSAk0rrfJ1umUMVbXhuVpRYrVSXLl3Qpk0bzJs3r87aydVbg0lJSUhJScHw4cNRXl4OAFi0aJGQ5Nzd3YWWHgC89dZbSElJQXJyMgYPHoy5c+fqJcL09HScOnVKaEE6ODhg/PjxSEhIqDeOVatWISUlBc8//zzKGtjp3cHBQW8j9g4dOsDb2xtpaWkA+OQ4e/ZsdOzYEd7e3nB3d8fff/8t/BxDhw5FWFgY2rZti8mTJ2PTpk3Ce6ampqKiogJDhw7VOwcbN25ERkYGACAtLQ19+vTR+xn69u1bb8yEGJP81CmodScbOjpCGhgIST3LDoFqXcHUYjUri1tuQxonODgYO3bswODBgzFixAjs379fmNTVqlUreHt74++//9Z7jWZSkYeHh7CE5eWXX8bTTz8tPCdIZxymZcuWiIiIQEREBHbs2IGIiAj06dNHaCGvW7cOSqVSr7uZMQZHR0cUFhaiRYsWaN++fY04NOuSferrxtJRW3ex5r633noLP//8Mz755BNERETAxcUFTz31FCorK4Wf9dy5czhy5AgOHDiAefPmIT4+HqdPn4ZarQYA7Nmzp0aXuWYttLVuV3z69GmoVCpI62nREMvHGNMbU3Xs2LFGwf1jy5dDpVZDKtFvJ3FSKeDgACiVwhZzxDyoxWrFWrdujeTkZOTn52PYsGFCXWSJRIKnn34a33//PXJ017vVwsfHR0ieERERcHCo/btWixYtMG3aNMyaNYuf7q9UYuPGjVi+fDlSUlKEy4ULFxAWFoZNmzYBAJ599lkcPHgQ5zXjQk2kVCpxRucPS3p6Ou7du4cOHToAAI4dO4a4uDiMGTMG0dHRCAgIwI0bN/SO4eDggCFDhmDp0qW4ePEibty4gV9//RUdO3aETCZDZmam3jmIiIgQJkd17NgRJ06c0Dte9duWKDAwECEhIXrFVYj1UeflgVX1SHGenjWSKgAE+vggpGVLBNbyRVXzfFZaSktuzIgSq5ULCQnBkSNHUFBQgGHDhqGoqnzZokWLEBwcjN69eyMhIQEXL15ERkYGkpKS8McffxjUknnttdeQnp6OHTt2YPfu3SgsLMQLL7yAzp07612eeuopYcb3jBkz0LdvXzzyyCP47LPPcO7cOVy/fh0///wz9u3b12Acjo6OmDZtGk6ePIlz587hueeeQ58+ffDggw8C4GcX//TTT0JSnzBhgtASBYDdu3fj888/R0pKCm7evImNGzdCrVYjKioKHh4emDVrFmbMmIENGzYgIyMD58+fx1dffYUNGzYA4Fv0mpnH6enp2Lx5M9avX9/kc0eIIYT1qgAkXl5Nfr3eOKvObjjEtKgruD4KBb8cxsTv0VzBwcHCOOjQoUNx4MAB+Pr64tSpU1iyZAmWLVuG69evQyKRoH379hg/fjymT5/e5Pdp1aoVJk+ejPj4eISHh2PIkCHwquU/+7hx47Bo0SKcO3cO3bt3x6FDh7By5UokJiZizpw5UKvVCA8PR2xsLGbMmFHve7q6uuLtt9/GhAkTkJ2djQEDBuiN4X766ad4/vnn0a9fP7Rs2RJvv/223o5G3t7e+OmnnxAfH4+Kigq0b98eW7ZsQadOnQAAH374Ifz8/LB48WJcu3YN3t7e6N69O959910AfK/Ajh07MGPGDKxatQoPPvggFi1ahOeff77J54+QplLqzHmQGLB+X3c7OdU//8BBZ405MR2OWesgUiMVFxfDy8sLRUVF8Ky25quiogLXr19HeHg4nHW+2RWvWCF0v5gL5+EBz5kzzfqexDTq+lyZ0zfffIOSkhK4u7vjP1Qq02oJf4ukUjh26VLrfIN1+/ejtKICbs7OeKFa9TN1SQmUly8DAJx69oTL44+bJW57Ry3WWkjc3aFu+GlGf09CjOWDDz4Qto2jxGqdNKVVAb7lWdea78XbtuFWQQGCfH1rJFa9rmAqH2o2lFhrQcXwCSFi090ajnN1NegYnIMDOGdnsIoKqPLywCor9fZqJaZBk5cIIcQCqW/fFq5zzajzy2l6w9Rq/V1xiMlQYiWEEAukW2WptmU2jcXpDDMpqsZbiWlRYiWEEAuk0k2sOlWUmkq3UL8iNdVqi55YE0qssN7qOsQy0eeJGIPQYnVwAFdH4ZbG4BwcwFUlV1ZcDGW1SmjE+Ow6sWp2ammoXi0hTaEpp0jlBImhWEWFds9VIyzZkrZqJVyvOHwYTKVq9jFJ3ex6VrBUKoW3tzfyqyqSuLq6Nmk7NUKqU6vVuH37NlxdXessD0lIQ3SL7jenG1g4hqcnOFdXsLIyqG/fRuXZs5BVVS8jxmf3//M1G3nnU7kvYiQSiQStW7emL2nEYCqd3WiMklg5DtLQUCjT0wEA8uRkOHXrBq7a/srEOOw+sXIch8DAQPj5+UFhhPKChDg5OUEiEXeUJTIyEl5eXvBvYGsxYpn0tnlrILG2DwqCl6sr/Ly9632exM0NkhYtoC4sBCsrg+LSJTh1726EaEl1dp9YNaRSKY2JEZvx66+/ih0CaYamdAXvW7iw0ceV+PkJx668eJESq4nY9eQlQgixRHqJ1YiVkiRubkILWJWZCXV5udGOTbQosRJCiIUREqtU2qylNrURtp9jTG9bOmI8lFgJIcSCMJUKrGrrQ2NMXKpOd/s5VVaW0Y9PRE6sixcvRq9eveDh4QE/Pz+MHj0a6VWz1jTi4uLAcZzepU+fPiJFTIh1mDhxIoYPH46JEyeKHQppInVREVBVZKQx3cDPLV+OJ+fPx3PLlzfq+Jybm3CdagebhqiTl5KTk/Haa6+hV69eUCqVmDt3LoYNG4bU1FS46fzyR4wYgcTEROG2E+3OQEi9kpOThW3jiHXRHV9taEYwABz7809h27jG4Bwc+OPK5VDl5oKpVOBo4qZRiZpY9+/fr3c7MTERfn5+OHv2LB5++GHhfplMJqw3JYQQW2aqiUu6JK6uUMvlgEoFdUEBpH5+Jnkfe2VRY6xFRUUAAB8fH737jxw5Aj8/P0RGRuLFF1+kYg6EEJtl7KpLtdHbAF1nezpiHBazjpUxhpkzZ2LAgAHo3LmzcH9sbCz+9a9/ISwsDNevX8f777+PRx55BGfPnoWslg+dXC6HXC4XbhdXTQIghBBrYJbEqrO/qzo/H+jUySTvY68sJrG+/vrruHjxIn777Te9+8ePHy9c79y5M3r27ImwsDDs2bMHY8eOrXGcxYsXY8GCBSaPlxBCTEFvjNVEXcF6LVbqATQ6i+gKnjZtGnbt2oXDhw8jJCSk3ucGBgYiLCwMV65cqfXxOXPmoKioSLhk0XRyQoiVYIxpE6uTk+nqTctkQNWx9conEqMQtcXKGMO0adOQlJSEI0eOIDw8vMHXFBQUICsrC4GBgbU+LpPJau0iJoQQS8fKyoCqoSxTdQMDfI10ODkBcjnUd++CMUabRhiRqC3W1157Dd9//z02b94MDw8P5OXlIS8vD+VVZbZKSkowa9Ys/PHHH7hx4waOHDmCkSNHomXLlhgzZoyYoRNCiNGpCwqE68bYh7U+QuJWKsHu3zfpe9kbURPr6tWrUVRUhEGDBiEwMFC4bNu2DQBfGP/SpUsYNWoUIiMjMWXKFERGRuKPP/6Ah071EEIIsQVqI28XVx/dxE3dwcYleldwfVxcXPDzzz+bKRpCbMeLL76IoqIieGnqwhKroNdibWRifW7YMBSXlcHT1bVJ76V7fPXdu0CbNk16PambxcwKJoQYz/z588UOgRhAdeeOcL2xXcFzn33WoPfSLT6hvnfPoGOQ2lnErGBCCCGAWlOsQTO5yIQosZoOJVZCCLEATKkUxjo5Z2fTz9LV7QqmxGpUlFgJIcQCqO/c0e5qo1MZyVQ4iQSo2utVrygFaTZKrITYoJCQEHAc12DBFWI5VLm5wvWmJNaI556D65NPIuK555r8npoJTKykBEypbPLrSe0osRJCiAXQ3RuVa+IMX0PpjbNWbYJCmo8SKyGEWADlrVvCdXMlVtAEJpOgxEoIISJjFRVQ5+UBqJq4ZKaNx3VbrIxarEZDiZUQQkSmvHZNO3HJjFXlaMmNaVBiJYQQkSl0duuSeHqa741pjNUkKLESQoiImEIBRWoqf0MiEa/FSonVaCixEkKIiCovXAAqKwEAkhYt+PWlZsJJpUDVeC51BRsPJVZCCBEJU6kg//134bakVSuzx6BptbLiYjC12uzvb4sosRJCiEgUFy+CVbUUOU9PSMy1zEaXpjuYMbDiYvO/vw2i3W0IsUHff/895HI5ZCbe05MYjjEG+R9/CLelAQEGHSdh5kzIFQrIHB0Nej0nk0Gzgae6qAgSb2+DjkO0KLESYoMGDRokdgikAaqsLGE3G87NDRJ3d4OO83B0dLPiqLHkJiysWccj1BVMCCGiEGYCA5C0bClaHHqJlYrxGwUlVkIIMTPGGBR//83f4Dhxu1+pSITRUVcwITboyJEjwhgrdQtbHlZUJJQQ5Nzdm1XC8OilS8IYqyHdwhzty2p0lFgJsUGTJk1CTk4OgoODkZ2dLXY4pBrlzZvCdUPHVjWeX7ECtwoKEOTri6uJiU1+PSeV8vuyKpXUFWwk1BVMCCFmpsrKEq5zzUysxqC3lpX2ZW02SqyEEGJmqqqdbAAzbhFXD73uYGq1NptBifX69evGjoMQQuwCU6uhys/nbzg5mW2LuHrpJtaCAhEDsQ0GJdaIiAgMHjwY33//PSoqKgx+88WLF6NXr17w8PCAn58fRo8ejfT0dL3nMMYQHx+PoKAguLi4YNCgQfjrr78Mfk9CCBGTurAQUCgAWEZrFeD3gNVQ370rYiS2waDEeuHCBXTr1g3/93//h4CAALz00ks4depUk4+TnJyM1157DSdOnMDBgwehVCoxbNgwlJaWCs9ZunQpVqxYgS+//BKnT59GQEAAhg4divv37xsSOiGEiEpTFALQT2hi4qjFalQGJdbOnTtjxYoVyMnJQWJiIvLy8jBgwAB06tQJK1aswG2dD0599u/fj7i4OHTq1AkxMTFITExEZmYmzp49C4Bvra5cuRJz587F2LFj0blzZ2zYsAFlZWXYvHmzIaETQoio1HfuCNctJrHqxKHSiY8YplmTlxwcHDBmzBj88MMPWLJkCTIyMjBr1iyEhITg3//+N3Jzc5t0vKKqdV0+Pj4A+LHcvLw8DBs2THiOTCbDwIEDcfz48VqPIZfLUVxcrHchhBBLodJpEVpMYpVKgapaw+r8fDDGGngFqU+zEuuZM2fw6quvIjAwECtWrMCsWbOQkZGBX3/9FTk5ORg1alSjj8UYw8yZMzFgwAB07twZAJBXNXPO399f77n+/v7CY9UtXrwYXl5ewiU0NNTAn44QQoxPt6uVs6BNEjgXFwAAq6gAKykRORrrZlBiXbFiBaKjo9GvXz/cunULGzduxM2bN/HRRx8hPDwc/fv3x5o1a3Du3LlGH/P111/HxYsXsWXLlhqPcRynd5sxVuM+jTlz5qCoqEi4ZOmsFyOEELEJk4McHS1jRnAVve5gzaxlYhCDKi+tXr0azz//PJ577jkE1LHVUevWrbFu3bpGHW/atGnYtWsXjh49ipCQEOF+zbHz8vIQGBgo3J+fn1+jFashk8loqyxi96jakmVilZVgVZMzdYvfN4ch1ZZqo2mxAoDq1i04tmtnlOPaI4NarAcPHsTbb79dI6kyxpCZmQkAcHJywpQpU+o9DmMMr7/+On766Sf8+uuvCA8P13s8PDwcAQEBOHjwoHBfZWUlkpOT0a9fP0NCJ4QQ0ejW4rWkbmAAepusq27dEjES62dQi7Vdu3bIzc2Fn5+f3v13795FeHg4VCpVo47z2muvYfPmzfjvf/8LDw8PYdzUy8sLLi4u4DgO06dPx6JFi9C+fXu0b98eixYtgqurKyZMmGBI6IQQAMeOAdu2AX//DbRqBYwZA4wbB1hQz6RN0qtqZKQWq9E4OwMSCaBWQ5WTI3Y0Vs2gxFrXjLGSkhI4N2GW2+rVqwHU3JQ5MTERcXFxAIDZs2ejvLwcr776KgoLC9G7d28cOHAAHh4ehoROiF3LzQVefBHYs0f//q1bgX79gF27AF9fcWKzB5bcYuU4DpybG9j9+2D370NdWAhJixZih2WVmpRYZ86cCYD/BcybNw+uul0HKhVOnjyJrl27Nvp4jZnSzXEc4uPjER8f35RQCbFrCxYsQFFREby8vDB//nwAfCt13DigrmXmx48Dgwbx/9L3VtPQbbEaa4x14ZYtKC4rg6erK+Y++2yzjiVxd4eqqviO8sYNOFFiNUiTEuv58+cB8Anx0qVLcNL5YDg5OSEmJgazZs0yboSEkCZbu3atsG3c/PnzsXEjMHWqUEkPrq5Ar15A69Z8ok1OBsrLgT//BF55BfjuO6COifekGdQ66+qNlVgTDxwQto1rbmLlPDz4bg0AymvX4NStmzFCtDtNSqyHDx8GADz33HP47LPP4OnpaZKgCCHGM38+8MEH2tvBwcCjj/JDagCfXEeOBJKS+MS7aRPw9NPAk0+KE68t02xuDsDyxlgBcG5u/EC7SgXFlStgKpVFLQmyFgbNCk5MTKSkSogVKCjQT6odOwKxsdqkquHtDQwYoL09axZQWWmWEO2KWpNYHR3rXIsvJo7jINH8bZfLobxxQ9R4rFWjW6xjx47F+vXr4enpibFjx9b73J9++qnZgRFCDMMY360LALqbT/XpA0RH193FGxHBzxLOzQWuXAESEoCXXzZ9vPaCKRRGX8NqChJvb2EsWJGaSutZDdDoFquXl5fwDUu3ZGBtF0KI+ZWXA5s3A717A7o7f8lkwIgRQJcu9Y+bchz/Wo1lywCl0nTx2htTjK+aAuflxS+7AaBMSwNr5PJJotXoFmuiTnWPRCNV+iCENA9jwIkTwLp1wPbtgO4QHsAPl40bB7i7N+54fn5ASAiQnQ1cuwbs2AGMH2/8uO2R3vhqVcF7S8RJJJB4eUFdWAhWXg7VzZtwaNtW7LCsikFjrOXl5SgrKxNu37x5EytXrsSBAweMFhghpH6//86Pi/brxydW3b/bVQ0OODs3PqlqxMRor3/5ZfPjJDxrabECfHewhiI1VbxArJRBiXXUqFHYuHEjAODevXt48MEHsXz5cowaNUoo+kAIMQ2FApg+nU+qursnOjoCkZH8DF+dsq9NFhQEaJYv/vYbcOlSs8IlVawpsXKensK4geLKFdpGrokMSqznzp3DQw89BADYvn07AgICcPPmTWzcuBGff/65UQMkhGiVlQGPPQZ89pn2vhYtgIEDgcmT+QIPOvtVGITjgAce0N5es6Z5xyM8prs3tAV3BQP8/qxcVVcHKy6Guq6qIqRWBpU0LCsrE0oKHjhwAGPHjoVEIkGfPn1w8+ZNowZICOFVVvJrSw8d4m9LJPxko06dtF2/GoGBA1FRcQfOzi0Neq/ISODkSUCl4idELV/OT4IihjNVi/Whzp1RUFwMXyMvgZR4eupVYZJWqw1P6mZQYo2IiMDOnTsxZswY/Pzzz5gxYwYAfjs3Wt9KiGlMm6ZNqo6O/HrUOnZtxCOPbGrWezk5AeHhwNWrQGEhsHs3PwmKGE5IrBwHOBj0p7dWif/3f0Y7li5OZ3BelZUFPPigSd7HFhnUFTxv3jzMmjULbdq0Qe/evdG3b18AfOu1G5XAIsTotm4FvvmGvy6V8t3BdSVVY4mM1F7fsMG072UPmIUXh6iOc3XVLrup2g6UNI5BX5ueeuopDBgwALm5uYjRmUL46KOPYsyYMUYLjhAC3LrF1+/VeOghwN/f9O8bFAS4uQGlpcC+fXwVJ9r5xjCsshKsqlqHpU9c0uA4DpyrK1hJCT/OWlICSVOnmNspg1qsABAQEIBu3bpBojO48+CDD6JDhw5GCYwQwps5E9DsNtaunX5L0pQkEv79AL5QxI4d5nlfW6Q3vmrhE5d0cbo7mFUV5ycNM6jFWlpaio8//hiHDh1Cfn4+1Gq13uPXrl0zSnCE2Ltff+U3JAf4Nan9+zfudbt3P4Ly8n/g4uKPJ5741eD3j4gALl7kr2/aBPznPwYfyq7pzQg2cos1du5c5N+7Bz9vb+xbuNCox9ZLrHl5cGzf3qjHt1UGJdapU6ciOTkZkydPRmBgoFWMFxBibdRqvhi+Ru/eNYvn16Wo6DJKS3NQWVnU8JPr4esLeHnxxSeOHeO7pYOCmnVIu2TKFuuVW7dwq6AARTpFe4xF4uICTUFDdV6e0Y9vqwxKrPv27cOePXvQv7FfnwkhTbZlC1C1BTJatjRfF7AujuO7g8+d48snbt8OvPGG+eOwdtZUHEKPszP/IWAMqjt3xI7Gahg0xtqiRQv4+PgYOxZCSBWlEoiP197u3Vu8jcd1NzfRdEuTprGWOsHVcRwHrmoBs/rOHbBqw36kdgYl1g8//BDz5s3TqxdMCDGeTZv4NaQA3/UaHCxeLC1aaEscHj8OZGWJF4u1stoWKwBOM/6gVkOtu20SqZNBXcHLly9HRkYG/P390aZNGzhW+wZ27tw5owRHiD1SqYBFi7S3e/QQLxaNdu2AM2f46z/+yM9UJo0nbHBu5OIQZqEzsK++fRvSloZV87InBv2GR48ebeQwCCEaP/0EXL7MXw8MbH7tX2No21abWH/4gRJrUwmJ1cnJ6iZ7crqJlVqsjWJQYp0/f76x4yCEgJ8g9PHH2tuWUsjM2xvw8eE3UD95ErhxA2jTRuSgrASrqOALPcP6uoEBCGOsAKCixNooBheIuHfvHr799lvMmTMHd6tO9rlz55CTk9PoYxw9ehQjR45EUFAQOI7Dzp079R6Pi4vjB891Ln369DE0ZEIs3uHD/AxcgJ8JLObYanW6e13/+KN4cVgbtc7EJWsqDqGhm1ipxdo4BiXWixcvIjIyEkuWLMEnn3yCe1VlYZKSkjBnzpxGH6e0tBQxMTH4sp7dlEeMGIHc3FzhsnfvXkNCJsQqLFumvR4TI95M4NrQ7GDD6CZWYxeHMAfOwYEvUA1AXVAgcjTWwaCu4JkzZyIuLg5Lly4Vto8DgNjYWEyYMKHRx4mNjUVsbGy9z5HJZAgwdbVxQizAX38B+/fz1z08+N1lDNW9+zwoFCVwdDRebVcvL74VfecOcPYsP2s5IsJoh7dZak09Sui3/oxlzvjxKK2ogFtjq4cYgHN2BistBbt/H0yhsMqWtzkZlFhPnz6NNbXsfhwcHIw8I1fnOHLkCPz8/ODt7Y2BAwdi4cKF8KtnX0C5XA65XC7cLtYtJUaIBVu5Unu9c+eae6w2xQMPmKb2YLt2fGIF+Fbr3LkmeRubopdYTdBifWHECKMfszrOyQmstBQA//NIW7Uy+XtaM4P+6zo7O9easNLT09HKiCc8NjYWmzZtwq+//orly5fj9OnTeOSRR/QSZ3WLFy+Gl5eXcAkNDTVaPISYSn4+8N13/HVHRyAqStx46qLbHbxli3hxWBNTJ1az0B1nLSwUMRDrYFBiHTVqFD744AMoFAoAfHWOzMxMvPPOOxhnxN2Qx48fj8cffxydO3fGyJEjsW/fPly+fBl79uyp8zVz5sxBUVGRcMmi1ezECnz9NaD5vvjAA5Y7FOfurt2y7q+/gEuXxI3HGjCdxGqxv9gGcJRYm8SgxPrJJ5/g9u3b8PPzQ3l5OQYOHIiIiAh4eHhgoZF3V9AVGBiIsLAwXLlypc7nyGQyeHp66l0IsWRyObBqFX+d44BOnZp/zLKyXJSUZKOszPhbfemOq27aZPTD2xyhxWqiNay5d+8i+84d5Jpwxq5uS5sSa8MMGmP19PTEb7/9hsOHD+Ps2bNQq9Xo3r07hgwZYuz49BQUFCArKwuBlrBinhAj2boV+Ocf/nqbNvzEpeZKSuqF0tIcuLkFY+LE7OYfUEfbtnxpQ8b4xLpoUfPGg22ZurwcrLwcgGkmLgHAQ//3f7hVUIAgX19cTUw0yXvotVh1W+CkVk1OrGq1GuvXr8dPP/2EGzdugOM4hIeHIyAgAIyxJn0jKykpwVVNQVQA169fR0pKCnx8fODj44P4+HiMGzcOgYGBuHHjBt599120bNkSY8aMaWrYhFgkxoBPP9Xejo4WL5bGcnEBQkOBzEwgOxtITgYGDxY7Ksuku+7TVInVLHRmAVNibViTvmcyxvDkk09i6tSpyMnJQXR0NDp16oSbN28iLi6uyQnvzJkz6NatG7pVlZeZOXMmunXrhnnz5kEqleLSpUsYNWoUIiMjMWXKFERGRuKPP/7QW+JDiDU7cgS4cIG/3qqVdvzS0ul2B2smXZGadLtNrXbiEvh5NJrxYUqsDWtSi3X9+vU4evQoDh06hMHVvqL++uuvGD16NDZu3Ih///vfjTreoEGDwBir8/Gff/65KeERYnVWrNBej462rIIQ9WnThm/EKBR8FaYvvgDc3MSOyvLYTIsVfPysshKQy8HKy8G5uIgdksVqUot1y5YtePfdd2skVQB45JFH8M4772ATzWYgpFHS04Hdu/nrbm76JQMtnYODdulNSQmwY4e48Vgqte7m4CYs4GAOehOYqNVaryYl1osXL2JEPYuRY2NjcUHTr0UIqZdua7W5BSHEEBmpvW6iOTNWT6WTWK2+xUqJtdGa9F/57t278K9nEMjf3x+FNBWbkAb98w+wYQN/3dGRX7tqbfz9+TKHAD9WXM8qOLvEGNO2WGUycNb2zak6SqyN1qTftEqlgkM9m/RKpVIolcpmB0WIrfvyS+soCFEfjgM6dNDeXrdOvFgsESsq4gehob+nqbWiIhGN16TJS4wxxMXFQVZHl0Z9pQYJIbz79/nECvDJqXNnceNpjvbtgVOn+GVDiYnABx9Y55cEU1Dl5wvXbSKx6rZYdXfsITU0KbFOmTKlwec0dkYwIfZq7VpA05PWvj1fJtBaubryu/Bcu8bXO965E3j6abGjsgwqTdUPwDZm0Do68t8EGaOu4AY0KbEm0gwFQpqlogL45BPt7ZgY07zP448fglqthERiUHG1JnngAT6xAsDq1ZRYNdRmSqx7P/wQSrUaDiYewxXWssrlUBcWNrkgkD0x/f86QoggMRHIrSrf26YN0KKFad7H29t82+MEBfGTmIqK+ElMf/5p3d3bxqLSbKHJcSbtCo4MCTHZsavjnJzA5HJAoQArKwNHi5drZeXT1AixHpWVwOLF2ttVBcesXvWNA776SrxYLAWrqIC6oAAA31q1lZYdTWBqHEqshJhJYiKg2cUwNJQvYWgrIiO15WQ3bgTs/W+u6tYt4bottepoLWvjUFcwIWYglwO6Oyr26GHa97t6dTOUyjI4OLgiImKCad8M/NBb+/ZAaipQVgZ8+y3w1lsmf1uLpczW7ijEubqa9L22JSejTC6Hq0yG8QMHmvS9qMXaOJRYCTGDNWu0rdXWrQE/P9O+38mTs4Vt48yRWAF+XDU1lb/+xRfAjBl86UN7pNJJrBITt1jnrl8vbBtn6sQKSqyNQl3BhJhYSYl+a7VnT/FiMSVvb/5LA8B/idi+XdRwRMMYgzIzk7/h4KCXjKwdbXjeOJRYCTGx5cv5NZ4AX2i/ZUtx4zGlLl201z/5hC8cYW/U+flCWS3Ozc1mJi4BAOfgIHRD6O7cQ/RRYiXEhPLytOtWOQ7o1UvceEwtMBDw9eWvnz3Lb4Jub5Q3bwrXJdZc/aMOmnFWVlwMVlWykeijxEqICc2bx3cFA3whBU3RelvFcfpFL5YtEy8Wsag03cAAOA8PESMxDZrA1DBKrISYyIUL2sL0jo6mnwlsKdq21ZZp3LsXuHRJ3HjMiTGmbbFKJLZRyrAavcRatVaX6KPESogJMAa8+SagVvO3u3UDbPBvbK0kEv2xVntqtaoLC8Gquig4d3ebGl8V6CRW3f1miRYlVkJM4McfteOLnp5AdLS48ZhbVJT27++WLYDOsKNNU9n4+Cqgv1MPtVhrR4mVECMrKQFmztTe7tsXkErFi0cMjo7aModKJbBihbjxmItSd3zVHhIrtVhrRYmVECP76CMgJ4e/HhqqXdtpTi4uAXBzC4aLS4D537xK587aLxRr1wK3b4sWitmozFhxScO/RQsE+frC31Q7OlTDSSTCpruq27fB7HFNVQPstC4KIaaRmsqvWwX4pNKvHz9T1tzGjj1j/jetxtmZnwn9559AeTnw+efAhx+KHZXpqMvLhRYc5+rKJyAz+F2E7gDO2RmsshKorAQrKgLn7W32GCwZtVgJMRLGgFdf5bs+AX7Zia0vr2lIly7aLxZffgkUF4sbjympNN0UsK3C+7XRne2su6E74YmaWI8ePYqRI0ciKCgIHMdh586deo8zxhAfH4+goCC4uLhg0KBB+Ouvv8QJlpAGfPeddsKShwfQtauo4VgEd3e+OD8A3LvH10y2VZRYiYaoibW0tBQxMTH48ssva3186dKlWLFiBb788kucPn0aAQEBGDp0KO7fv2/mSAmp3927wKxZ2tsDBthvAfrqdL9grFgBVFSIFopJ6W4VJzHT+KpYJLqJVbOhOxGI+l8/NjYWsbGxtT7GGMPKlSsxd+5cjB07FgCwYcMG+Pv7Y/PmzXjppZfMGSoh9Zo7Vzs5Jzycn7QkpqNHX4JcfhcymQ8efljcZqK3N39Orl/nSzyuXw+8/LKoIZmEKjeXvyKVmrXw/utffYXC+/fRwsMDX772mnne1NmZX7CsVmt/biKw2DHW69evIy8vD8OGDRPuk8lkGDhwII4fP17n6+RyOYqLi/UuhJjS6dPaLk5HR37Cktiysvbg+vXtyMraI3YoAPgCGRpLlmjHoW2FurQUrKonjXNxMWthiP1nziDp+HHsP2O+CWscxwmzntm9e1CXlZntva2BxSbWvKruBX9/f737/f39hcdqs3jxYnh5eQmXULGbDsSmqVT8hCXNioMePQAbH14zSMuWQEgIf/3GDWDrVlHDMTrdVpu5ltmITffn1B1fJhacWDWqf/NjjNX7bXDOnDkoKioSLlma3aUJMYGEBEDTUGjRgl+7SWqn22pdvFhb7tEW6I4z2mJ94NrobuCuu/EAseDEGhDAL2yv3jrNz8+v0YrVJZPJ4OnpqXchxBQKC4E5c7S3+/fnh51I7QIDgar/1khNBaotArBqap2ZsXbTYtVJrEpqwOix2D8D4eHhCAgIwMGDB4X7KisrkZycjH6WMIhF7N6CBYCmVGrbtkBQkLjxWAPdGcILF9rORujCkhOO0yv5Z8s4JydtBabsbNqbVYeoibWkpAQpKSlISUkBwE9YSklJQWZmJjiOw/Tp07Fo0SIkJSXhzz//RFxcHFxdXTFhwgQxwyYEaWl8wQOAnwTap4+48ViL0FB+vBUAzp0Dfv5Z3HiMgSmV2opLzs62uaNNHSSa/WZVKqio1SoQNbGeOXMG3bp1Q7eqwZeZM2eiW7dumDdvHgBg9uzZmD59Ol599VX07NkTOTk5OHDgADxscPNgYl3eeoufuATwrTAbrbdudBxXs9Vq7dR37ghNb3tprWrobuSuvHZNxEgsi6jrWAcNGlRvAWeO4xAfH4/4+HjzBUVIAw4dAvZUrWJxc+NLF5LGCw/n17beuwf89htfrWrgQLGjMpwqP1+4bi8TlzQkHh6o+n5JiVWHxY6xEmKJ1Gq+tarRqxdVWGoqjtOfIWzthfnVdpxYOUdH4WdW5eZCXVoqckSWgf4kENIEW7cC58/z1319tXVwLU27ds9CLi+ETGaercSaql074OxZvij/oUPAH3/w+9ZaI5XOfnhidAU//fDDKCwpQQuRxiM4T0+w8nIAgDIjA05duogShyXhmI1vpldcXAwvLy8UFRXR0hvSLJWV/DZomh6vxx7TFj0gTff338DRo/z12Fhg715x4zFU8Wefgd27B0gkcIyJsavJSwCgvn8fyitXAACOXbrAdcwYkSMSH3UFE9JIa9dqk2pwMCXV5mrfXjvpa98+vjSktWGVlXxShf3NCNbg3NyEBdzKq1dp43NQYiWkUcrKgI8+0t7u1Uu8WGyFVKo/Q/iDD0QLxWCaZTaA/c0I1uAkEmF2MCsrg5p2u6HESkhjfPklvzMLwM9q9fMTNx5bERWlra28ezc/7mpN9MZX7Wziki6JzjCb4upVESOxDJRYCWlAcTG/I4tGz57ixdJY27Z1QGKiJ7Zt6yB2KPWq3mpdsEC0UAyit9RGpBZr11degf/48ej6yiuivD+gUygCgPL6ddHisBSUWAlpwKef8huZA/y4YAvLnGirR6ksgUJxH0plidihNKhDB22r9X//025qYA3UFtBiLamowP3ycpSIuYO8TKYtb5iVBWZr+wI2ESVWQupx9y6wYgV/neP4beGIcUml+uta588XL5amElqsEgm/Ga+d4jhO22pVKu2+vCElVkLq8cknfFcwwI8H0oot04iK0s4Q3ruXX9dq6ZhcDlZUBMD8m5tbIk5nHa3y5k0RIxEfJVZC6nD7NvD55/x1iUS/VUWMq3qr9f33xYulscQuDGFpJJRYBZRYCanDkiWApkJbhw4A7f1gWlFR2nN86BBw+LC48TREbw9WO54RrMHpjrNmZ4NpdqmwQ5RYCanFrVvAV1/x16u3pohpSCT6M67ffdey92tVUWKtQaKZhaZUQmXH61kpsRJSi48+AjSTLDt21M5aJabVrp121vWJE8CuXeLGUx973tWmLrrjrKrMTBEjERclVkKquXYN+PZb/rqjo/46S2JaEol+Vas5cwBLXLnBGNO2yBwdwdEWRwCqyhtWUdrxzGBKrIRUM38+oFDw1zt3BqgxYl5hYYC/P389LQ3YsEHceGrD7t0D5HIA1FrVxbm4CHWDVdnZdls3mL5mEaLj0iVg0yb+ukxmvZuYDxjwNVSqckil1vdHn+OA3r213cDz5gHPPGNZ3fGq3FzhOufqKmIkwOevvooKuRzOMpmocQD8elbOzQ3s/n3+UlQEzttb7LDMjhIrITrefls7YaZbN2GSo9UJC3tC7BCaJSCAb7nevMlPJFu+nE+wlkI3sUpETqyPWdiOEJrECgDK7Gw42WFipa5gQqocPsxvXwbwxQo6dhQ3HnvXuzffegWApUv5BGspVDrBiN1itTQSna4Fe63ARImVEAAqFTBzpvZ2z54AzUcRl7c3v7E8wK8nfvddUcMRMMagzMnhbzg62nUpw9roTmBSZWeLGIl4KLESAmDjRiAlhb/u68sX27dmt2+fxT///IHbt61sH7ZqevbUdsdv2ACcOiVuPACgLijQTlxydRW9lOG5q1dx8u+/cc5CtmvjHByAqkpUqrw8MM1MQDtC38mJ3Ssu5pd1aPTtq+2CtFYHDoxCaWkO3NyCMXGi9bYanJ35jQ80tYOnTeOvS0RsEqh0yvVJLGBG1dMLF+JWQQGCfH1xNTFR7HAA8OdFXVEBqNVQ3boFh7AwsUMyK4tuscbHx/OzzHQuAQEBYodFbMxHHwGaIjpt2gBBQaKGQ6rp1ElbNOLUKWD9elHDgVKn8IFuQQSiZe/rWS06sQJAp06dkJubK1wuXbokdkjEhqSl8futAnzpwj59xI2H1CSRAP36aW+//bZ2f1xzY4xBeeMGf4PjaOJSHSR2XoHJ4hOrg4MDAgIChEurVq3EDonYCMaA11/XVvaJiaFt4SxVcDDQti1//c4d4J13xIlDXVAAVrWPIOfuDk7MPmlLJpMJs/+UWVl2VyjC4j8VV65cQVBQEMLDw/HMM8/g2rVr9T5fLpejuLhY70JIbb7/Hvj1V/66hweVLrR0fftqJ+CuXQv8/rv5Y1DqTBCS0LewOmkKRQAAKir0dgKyBxadWHv37o2NGzfi559/xtq1a5GXl4d+/fqhoKCgztcsXrwYXl5ewiU0NNSMERNrceeO/vKa/v1peY2lc3PTryP84ovC5FyzUVy+LFznKLHWS6Kzz6LQfW4nLDqxxsbGYty4cYiOjsaQIUOwZ88eAMCGeoqHzpkzB0VFRcIlyw4HzknDZszgkyvAdzG2bi1uPKRxOnYENKNBaWnAokXme291WRlUmgQhk9Hm5g3QndhFidWCubm5ITo6GleuXKnzOTKZDJ6ennoXQnTt3s13AwP8GkndiTHEskkkwMMPa5dDLVoEXLxonvdWpqUJ9S4lXl6ir1+1dJyLi3ac9fp1u9r43KoSq1wuR1paGgIDA8UOhVipwkLgpZe0t/v2BWhip3Xx9dWOhyuVQFycdjciU6rUyeASHx/Tv6GV4zhO2x1cWWlX5Q0tOrHOmjULycnJuH79Ok6ePImnnnoKxcXFmDJlitihESs1bZq25mxoKBAZKW48xDDdu2vXtp4/b/ouYVVBgXbZiLMzbRXXSLrj0Ip6ehptjUVP18jOzsazzz6LO3fuoFWrVujTpw9OnDiBMDur4kGM48cftVvCOTnpdynamn/9Kw0AA2CbP6BUCgwaBOzcyffOfvgh8Nhj+pObjKnyrLY0pNTX16K6gc9/9ZXF/qYlXl7QdAAr//4bbMgQizp3pmLRiXXr1q1ih0BsRE6Ofhdw//6Wtb+nsTk5eTT8JCvXqhW/td+5c/wmCpMn89eN3bXPFAoozp/nb3AcJL6+xn2DZvKw4LEMzsEBnLs7WEkJ1HfvQp2fD6lmF3sbZtFdwYQYg1oNTJnCj68C/CzgiAhxYyLG0b27dpZwerr+EipjUVy8CFZRAQCQtGjBF5knjSbR9NlDf5zallFiJTbvk0+AQ4f4625uwIABttsFbG8kEmDwYO0a5DVrgJ9+Mt7xGWOQnzypfT8/P+Md3E7oJlbFxYt2MTuYvnoRm3byJDB3rvb24MHCjlY27eLFFaisLIaTkye6dDFBM86CeHvzs7uPHeNvv/ACv92cMdYmKzMyoL59GwBfWF5igd2un+/cieKyMni6uuKN0aPFDqcGzsEBnLc32L17YCUlUPz9N5w6dRI7LJOiFiuxWffuAc88o60F3LWr/excc+nSCpw7twCXLq0QOxSz6NBBW0tY83s3xhKcSp3WqtRCW6uf//e/WLR1Kz7/73/FDqVO0pYtheuVf/xh87WDKbESm8QY8PzzgKbgi78/34ohtonjgIce4ms+A/yerc0t1K+6c0dbG9jJCZy3d/MOaMc4Dw9hiZIqJwfKBmq+WztKrMQmffopkJTEX5fJgEcfFXdzbGJ61X/PK1YAO3YYfjy91mqrVnaxTMRUOI6DRGc2sPzwYZtutdKfGmJzjh4FZs/W3h48GKD9qO2Dn5/+nrpxccDffzf9OOryclReuMDfkEgsbomNNZK0aCHUV1bl5ECZni5yRKZDiZXYlJwc4Omn+XWNAD+uSgX27UunTtrlVCUlwOjRQFFR045RefasMEgr8fWlJTZGwHEcpDqTHCp++QVMrRYxItOhxEpsRkUFMHYsoNn6MTiYxlXtkWa8VVPONz0dmDhR+2WrIUyprNENTIyD8/IS9mlVFxRAkZIibkAmQomV2ATGgKlTgVOn+Nvu7jSuas8cHYFhw/hxVwDYs6fxk5kUFy+ClZQAqEoE9rA+y0w4joM0OFi4XXHkCJg5dlAwM/qzQ2zCggXaOsAODvwfVfp7aN88PYEhQ7TFQD75BPjmm/pfw1QqyH/7TbgtDQgwYYT2SeLuDs7LCwDA7t9H5enTIkdkfJRYidVbt45PrBqDBwM6y+aIHQsO5utCa7z6Kt96rYviwgWoq2pfch4ekNhyQWkR6Y61yn//HUwuFzEa46PESqxaUhLwn/9ob/fpA4SHixePpfD17Q4/vz7w9e0udiii69gR6NKFv65S8ZPbjh+v+Twml6Pi8GHhttRK9n3u2q4dHoyKQtd27cQOpdEkLi5CqUNWVga5ZgzHRnDMlhcTASguLoaXlxeKiorgqbM3ILF+u3fzk5U0QzSdO/Ol7Wi5IamOMb5etKYugbc3cPiwdsN0ACjfu1foluS8vOBoRYnKGrGKCihSUwEAnLMzPN5802bGs6nFSqzSjh36SbV9e0qqpG4cxw8RaObN3LvHj79qNltRXL6sHevjODiEhIgSpz3hnJ0hqZq6zSoqIP/jD5EjMh5KrMTqrF7Nd+dpkmq7dsDAgZRUSf2kUn5Sm6YAUEEBn2wv/pqHMp0tcaTBweA004mJSel2t8tPnIC6tFTEaIyHEiuxGgoF8MYb/AQUzbryyEj+jyMtqyGN4egIxMbyFZoAIMgxD+4/fwdUTZ7hvLwgoXWrZsPJZJBoZhpWVkKuM8ZtzaicCLEKN27wi/x1J53ExAAPPkgt1drs3/8kKipuw9m5FUaM2CV2OBbFyQl47DHgzoWb+Gr4Fng580m1QuIGjzZtrK4m8FMffYQ7RUVo6eWF7e+9J3Y4TSYNDIT67l1ArUbluXNw6tHDaiaO1YW+5xOLplYDX3/Nz+rUJFWJBHj4YaB3b0qqdSkoOIf8/BMoKDgndigWKcbjMhJHfi8k1fwSN+w42w7HjkuhtLJ9uFMyMnAqPR0pGRlih2IQztFRu16YMZT9739Wvxk6JVZisY4e5ZfPvPIKcP8+f5+HB/Dkk/z+m4QYoovzX/i3zzY4SviNev8p88TPlyNQqXJAWhq/hOtOgchB2hmJn58wI1idm4uKQ4dEjqh5KLESi8IYcPAgP2Nz4EBAtyhLVBQwbpx2fIyQpopx/hPPttgBKccP0t9RtsAN1hZ+AVKh9+PuXT65njoNKJQiBmtHOIkE0rAwoQuq8o8/rHptK42xEouQlQVs2QIkJPBF03W1aMFXz9Ep1kJIk/FJ9SdIOH7pfr7CF9cqWwPg4OXFl8DMyeHnManVwPnzwOXL/EYOkZGAhIYdTEri5gZpSAhUWVkAgIp9+8BKSiAbNAiclc1OpMRKRKFUAufOAT//zBd6qO3LqYcH0L07v0bVyv5fEQvTy/UcxnntFpLqPwpfXK9KqhoyGV+1684dfikOY0BpKZCczH9Wo6OBqEh+8hMxDWmrVmCVlVBXbVElP3YMyowMOMfGWtXaYqtIrKtWrcKyZcuQm5uLTp06YeXKlXjooYfEDos0wd27wJkzwMmT/CSk48eB4uLanxsYyO+p2aYNJVTSPBKoMczjVzzi8btw3z+KlrheGQrdpKrBcUCrVoCXF7/9YNUmN7h/n//MnjrFJ9927fhiEw5SM/0gdkQaFATOwQGqnBwAgOrWLZSuWweH9u0h698f0tatLX7mtsUn1m3btmH69OlYtWoV+vfvjzVr1iA2NhapqaloTTtYW5x794ArV/ju3NRU4M8/gQsXgMzM+l/n48P/wWrfnt+VhJDmYWjndAOPex5EiFOucG+uwg83K4NRW1LV5eQEhIYCZWV8C1ZTt0Cp5D/fV67wBScCAvgvgn5+gK8v4OLS0JFJQziOg9TfH5ybG1SZmWAVFQAA5ZUrUF65Aom/P5y6doVjx46QWOgfC4uvFdy7d290794dq1evFu574IEHMHr0aCxevLjB11Ot4MYrK+O7ZSsr+WLlajX/h0Sh4Medysv559y/DxQV8a3Q27eB3Fx+bErZxIkeLVrw46ahofz+qcR49uwJQXl5DlxcgvH449lih2Nyoc656OyeAW/HYoQ45yPK7WaN59yqaIkcuWHFHyor+R6WivKGnyt1AFxd+TFbZxmfpB0d+e0MJVJAKuH/5Tg+CUsk/PXAIMNawJGvvIJbd+8iyMcHl3X+TtoExqAuKID69u06nyINDoakZUtIPD3BubiAc3IC5+kJh4gI0Vq2Ft1iraysxNmzZ/FOtR2Khw0bhuO1bU8BQC6XQ66zBVFRUREAPsGSuuXl8etC790z33sWFvKXv/4y33vaD37Wa3m5Gtu32/Zn/5mY85gRu1/vvuKKms9zRzaiZAZ+yZAB8DDspQAAZdWlHsV3DDu0urJS+Pfu+fOGHcSaZWTwl2qkbdrA/dlna32Jh4eHaZMus2A5OTkMAPv999/17l+4cCGLjIys9TXz589nAOhCF7rQhS50qfWSn59v0txl0S1WjerfLBhjdX7bmDNnDmbOnCncvnfvHsLCwpCZmQmvql3rScOKi4sRGhqKrKws6kJvJDpnhqHz1nR0zgyjOW9OJp7abdGJtWXLlpBKpcjLy9O7Pz8/H/6aLSqqkclkkNWyM4WXlxd9AA3g6elJ562J6JwZhs5b09E5M4ypx14tejGDk5MTevTogYMHD+rdf/DgQfTr10+kqAghhJC6WXSLFQBmzpyJyZMno2fPnujbty+++eYbZGZm4uWXXxY7NEIIIaQGi0+s48ePR0FBAT744APk5uaic+fO2Lt3L8LCwhr1eplMhvnz59faPUzqRuet6eicGYbOW9PROTOMuc6bxa9jJYQQQqyJRY+xEkIIIdaGEishhBBiRJRYCSGEECOixEoIIYQYkdUl1lWrViE8PBzOzs7o0aMHjh07Vudz4+LiwHFcjUunTp2E56xfv77W51RU1FJs1Io15bwBwKZNmxATEwNXV1cEBgbiueeeQ0FBgd5zduzYgY4dO0Imk6Fjx45ISkoy5Y9gdsY+Z/RZq91XX32FBx54AC4uLoiKisLGjRtrPIc+a/oaOmf28Fk7evQoRo4ciaCgIHAch507dzb4muTkZPTo0QPOzs5o27Ytvv766xrPMcpnzaQFE41s69atzNHRka1du5alpqayN998k7m5ubGbN2/W+vx79+6x3Nxc4ZKVlcV8fHzY/PnzheckJiYyT09Pvefl5uaa6Scyj6aet2PHjjGJRMI+++wzdu3aNXbs2DHWqVMnNnr0aOE5x48fZ1KplC1atIilpaWxRYsWMQcHB3bixAlz/VgmZYpzRp+1mlatWsU8PDzY1q1bWUZGBtuyZQtzd3dnu3btEp5DnzV9jTln9vBZ27t3L5s7dy7bsWMHA8CSkpLqff61a9eYq6sre/PNN1lqaipbu3Ytc3R0ZNu3bxeeY6zPmlUl1gcffJC9/PLLevd16NCBvfPOO416fVJSEuM4jt24cUO4LzExkXl5eRkzTIvT1PO2bNky1rZtW737Pv/8cxYSEiLcfvrpp9mIESP0njN8+HD2zDPPGClqcZninNFnraa+ffuyWbNm6d335ptvsv79+wu36bOmrzHnzB4+a7oak1hnz57NOnTooHffSy+9xPr06SPcNtZnzWq6gjVbyA0bNkzv/vq2kKtu3bp1GDJkSI3iEiUlJQgLC0NISAieeOIJnLehrZcMOW/9+vVDdnY29u7dC8YY/vnnH2zfvh2PP/648Jw//vijxjGHDx/e6N+FJTPVOQPos1adXC6Hs7Oz3n0uLi44deoUFAoFAPqsVdeYcwbY9mfNEHV9js6cOWP0z5rVJNY7d+5ApVLVKL7v7+9fo0h/bXJzc7Fv3z5MnTpV7/4OHTpg/fr12LVrF7Zs2QJnZ2f0798fV65cMWr8YjHkvPXr1w+bNm3C+PHj4eTkhICAAHh7e+OLL74QnpOXl2fw78LSmeqc0WetpuHDh+Pbb7/F2bNnwRjDmTNnkJCQAIVCgTt3+A1K6bOmrzHnzNY/a4ao63OkVCqN/lmzmsSq0ZQt5HStX78e3t7eGD16tN79ffr0waRJkxATE4OHHnoIP/zwAyIjI/X+INqCppy31NRUvPHGG5g3bx7Onj2L/fv34/r16zXqMxv6u7AWxj5n9Fmr6f3330dsbCz69OkDR0dHjBo1CnFxcQAAqVRq0DGtkbHPmb181pqqtvNc/X5jfNasJrEasoWcBmMMCQkJmDx5coP78EkkEvTq1ctmvtkZct4WL16M/v3746233kKXLl0wfPhwrFq1CgkJCcjNzQUABAQEGPS7sAamOmfV0WeN78JMSEhAWVkZbty4gczMTLRp0wYeHh5o2bIlAPqsVdeYc1adrX3WDFHX58jBwQG+vr71PqepnzWrSazN2UIuOTkZV69exQsvvNDg+zDGkJKSgsDAwGbFaykMOW9lZWWQSPQ/GppvwppveH379q1xzAMHDtjEdn6mOmfV0WdNy9HRESEhIZBKpdi6dSueeOIJ4XzSZ6129Z2z6mzts2aIuj5HPXv2hKOjY73PafJnrUlTnUSmmZa+bt06lpqayqZPn87c3NyEWb7vvPMOmzx5co3XTZo0ifXu3bvWY8bHx7P9+/ezjIwMdv78efbcc88xBwcHdvLkSZP+LObU1POWmJjIHBwc2KpVq1hGRgb77bffWM+ePdmDDz4oPOf3339nUqmUffzxxywtLY19/PHHNrkEwpjnjD5rNc9beno6++6779jly5fZyZMn2fjx45mPjw+7fv268Bz6rDX9nNnDZ+3+/fvs/Pnz7Pz58wwAW7FiBTt//rywTKn6edMst5kxYwZLTU1l69atq7HcxlifNatKrIwx9tVXX7GwsDDm5OTEunfvzpKTk4XHpkyZwgYOHKj3/Hv37jEXFxf2zTff1Hq86dOns9atWzMnJyfWqlUrNmzYMHb8+HFT/giiaOp5+/zzz1nHjh2Zi4sLCwwMZBMnTmTZ2dl6z/nxxx9ZVFQUc3R0ZB06dGA7duwwx49iNsY+Z/RZq3neUlNTWdeuXZmLiwvz9PRko0aNYn///XeNY9JnbaBwuzHnzB4+a4cPH2YAalymTJnCGKv9/+iRI0dYt27dmJOTE2vTpg1bvXp1jeMa47NG28YRQgghRmQ1Y6yEEEKINaDESgghhBgRJVZCCCHEiCixEkIIIUZEiZUQQggxIkqshBBCiBFRYiWEEEKMiBIrIYQQYkSUWAkRwfHjxyGVSjFixAixQyGEGBlVXiJEBFOnToW7uzu+/fZbpKamonXr1qLEoVAohALkhBDjoBYrIWZWWlqKH374Aa+88gqeeOIJrF+/Xu/xXbt2oWfPnnB2dkbLli0xduxY4TG5XI7Zs2cjNDQUMpkM7du3x7p16wBo9xzWtXPnTr29JOPj49G1a1ckJCSgbdu2kMlkYIxh//79GDBgALy9veHr64snnngCGRkZesfKzs7GM888Ax8fH7i5uaFnz544efIkbty4AYlEgjNnzug9/4svvkBYWFidu/sQYqsosRJiZtu2bUNUVBSioqIwadIkJCYmCslnz549GDt2LB5//HGcP38ehw4dQs+ePYXX/vvf/8bWrVvx+eefIy0tDV9//TXc3d2b9P5Xr17FDz/8gB07diAlJQUAn+xnzpyJ06dP49ChQ5BIJBgzZgzUajUAoKSkBAMHDsStW7ewa9cuXLhwAbNnz4ZarUabNm0wZMgQJCYm6r1PYmIi4uLibGpDckIapcll+wkhzdKvXz+2cuVKxhhjCoWCtWzZkh08eJAxxljfvn3ZxIkTa31deno6AyA8t7rExETm5eWld19SUhLT/W8+f/585ujoyPLz8+uNMT8/nwFgly5dYowxtmbNGubh4cEKCgpqff62bdtYixYtWEVFBWOMsZSUFMZxnN5WZoTYC2qxEmJG6enpOHXqFJ555hkAgIODA8aPH4+EhAQAQEpKCh599NFaX5uSkgKpVIqBAwc2K4awsDC0atVK776MjAxMmDABbdu2haenJ8LDwwEAmZmZwnt369YNPj4+tR5z9OjRcHBwQFJSEgAgISEBgwcPRps2bZoVKyHWyEHsAAixJ+vWrYNSqURwcLBwH2MMjo6OKCwshIuLS52vre8xAJBIJDXGMxUKRY3nubm51bhv5MiRCA0Nxdq1axEUFAS1Wo3OnTujsrKyUe/t5OSEyZMnIzExEWPHjsXmzZuxcuXKel9DiK2iFishZqJUKrFx40YsX74cKSkpwuXChQsICwvDpk2b0KVLFxw6dKjW10dHR0OtViM5ObnWx1u1aoX79++jtLRUuE8zhlqfgoICpKWl4b333sOjjz6KBx54AIWFhXrP6dKlC1JSUnD37t06jzN16lT88ssvWLVqFRQKhd6kK0Lsith90YTYi6SkJObk5MTu3btX47F3332Xde3alR0+fJhJJBI2b948lpqayi5evMiWLFkiPC8uLo6FhoaypKQkdu3aNXb48GG2bds2xhhjBQUFzM3Njb3xxhvsypUrbNOmTSwoKKjGGGtMTIzee6tUKubr68smTZrErly5wg4dOsR69erFALCkpCTGGGNyuZxFRkayhx56iP32228sIyODbd++nR0/flzvWP369WNOTk7s5ZdfNtJZI8T6UIuVEDNZt24dhgwZAi8vrxqPjRs3DikpKfD09MSPP/6IXbt2oWvXrnjkkUdw8uRJ4XmrV6/GU089hVdffRUdOnTAiy++KLRQfXx88P3332Pv3r2Ijo7Gli1bEB8f32BcEokEW7duxdmzZ9G5c2fMmDEDy5Yt03uOk5MTDhw4AD8/Pzz22GOIjo7Gxx9/DKlUqve8F154AZWVlXj++ecNOEOE2AYqEEEIMZqFCxdi69atuHTpktihECIaarESQpqtpKQEp0+fxhdffIE33nhD7HAIERUlVkJIs73++usYMGAABg4cSN3AxO5RVzAhhBBiRNRiJYQQQoyIEishhBBiRJRYCSGEECOixEoIIYQYESVWQgghxIgosRJCCCFGRImVEEIIMSJKrIQQQogRUWIlhBBCjOj/AYlGRDIbrpPcAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 500x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---Prompt based mean and std---\n",
      "0.87268\n",
      "0.020258766003880886\n",
      "\n",
      "---KG-RAG based mean and std---\n",
      "0.9521866666666666\n",
      "0.012250017687062069\n"
     ]
    }
   ],
   "source": [
    "gpt_35_fig = plot_figure(gpt_35_prompt_correct_frac_list, gpt_35_rag_correct_frac_list)\n",
    "\n",
    "fig_path = '../data/results/figures'\n",
    "os.makedirs(fig_path, exist_ok=True)\n",
    "gpt_35_fig.savefig(os.path.join(fig_path, 'gpt_35_true_false.svg'), format='svg', bbox_inches='tight')      \n",
    "\n",
    "print('---Prompt based mean and std---')\n",
    "print(np.mean(gpt_35_prompt_correct_frac_list))\n",
    "print(np.std(gpt_35_prompt_correct_frac_list))\n",
    "print('')\n",
    "print('---KG-RAG based mean and std---')\n",
    "print(np.mean(gpt_35_rag_correct_frac_list))\n",
    "print(np.std(gpt_35_rag_correct_frac_list))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "e9f75a7f",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/p1/h56gxdhs5vgb0ztp7h4z606h0000gn/T/ipykernel_52094/309868377.py:80: FutureWarning: \n",
      "\n",
      "`shade` is now deprecated in favor of `fill`; setting `fill=True`.\n",
      "This will become an error in seaborn v0.14.0; please update your code.\n",
      "\n",
      "  sns.kdeplot(prompt_correct_frac_list, color=\"blue\", shade=True, label=\"Prompt based\", ax=ax, lw=2, linestyle=\"-\", alpha=0.6)\n",
      "/var/folders/p1/h56gxdhs5vgb0ztp7h4z606h0000gn/T/ipykernel_52094/309868377.py:81: FutureWarning: \n",
      "\n",
      "`shade` is now deprecated in favor of `fill`; setting `fill=True`.\n",
      "This will become an error in seaborn v0.14.0; please update your code.\n",
      "\n",
      "  sns.kdeplot(rag_correct_frac_list, color=\"lightcoral\", shade=True, label=\"KG-RAG based\", ax=ax, lw=2, linestyle=\"-\", alpha=0.6)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 500x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---Prompt based mean and std---\n",
      "0.9039666666666666\n",
      "0.017877328908114005\n",
      "\n",
      "---KG-RAG based mean and std---\n",
      "0.9459866666666666\n",
      "0.013465339868632277\n"
     ]
    }
   ],
   "source": [
    "gpt_4_fig = plot_figure(gpt_4_prompt_correct_frac_list, gpt_4_rag_correct_frac_list)\n",
    "\n",
    "fig_path = '../data/results/figures'\n",
    "os.makedirs(fig_path, exist_ok=True)\n",
    "gpt_4_fig.savefig(os.path.join(fig_path, 'gpt_4_true_false.svg'), format='svg', bbox_inches='tight')      \n",
    "\n",
    "print('---Prompt based mean and std---')\n",
    "print(np.mean(gpt_4_prompt_correct_frac_list))\n",
    "print(np.std(gpt_4_prompt_correct_frac_list))\n",
    "print('')\n",
    "print('---KG-RAG based mean and std---')\n",
    "print(np.mean(gpt_4_rag_correct_frac_list))\n",
    "print(np.std(gpt_4_rag_correct_frac_list))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "00bc1f64",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
